--- name: "hetrs2" 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/hetrs2" --- # hetrs2(3) {he,sy}trs2: solve using factor ## NAME hetrs2 - {he,sy}trs2: solve using factor ## SYNOPSIS ### Functions subroutine **chetrs2** (uplo, n, nrhs, a, lda, ipiv, b, ldb, work, info)\ **CHETRS2** subroutine **csytrs2** (uplo, n, nrhs, a, lda, ipiv, b, ldb, work, info)\ **CSYTRS2** subroutine **dsytrs2** (uplo, n, nrhs, a, lda, ipiv, b, ldb, work, info)\ **DSYTRS2** subroutine **ssytrs2** (uplo, n, nrhs, a, lda, ipiv, b, ldb, work, info)\ **SSYTRS2** subroutine **zhetrs2** (uplo, n, nrhs, a, lda, ipiv, b, ldb, work, info)\ **ZHETRS2** subroutine **zsytrs2** (uplo, n, nrhs, a, lda, ipiv, b, ldb, work, info)\ **ZSYTRS2** ## Detailed Description ## Function Documentation ### subroutine chetrs2 (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 info) **CHETRS2** **Purpose:** ``` !> !> CHETRS2 solves a system of linear equations A*X = B with a complex !> Hermitian matrix A using the factorization A = U*D*U**H or !> A = L*D*L**H computed by CHETRF and converted by CSYCONV. !> ``` **Parameters** *UPLO* ``` !> UPLO is CHARACTER*1 !> Specifies whether the details of the factorization are stored !> as an upper or lower triangular matrix. !> = 'U': Upper triangular, form is A = U*D*U**H; !> = 'L': Lower triangular, form is A = L*D*L**H. !> ``` *N* ``` !> N is INTEGER !> 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) !> The block diagonal matrix D and the multipliers used to !> obtain the factor U or L as computed by CHETRF. !> ``` *LDA* ``` !> LDA is INTEGER !> The leading dimension of the array A. LDA >= max(1,N). !> ``` *IPIV* ``` !> IPIV is INTEGER array, dimension (N) !> Details of the interchanges and the block structure of D !> as determined by CHETRF. !> ``` *B* ``` !> B is COMPLEX array, dimension (LDB,NRHS) !> On entry, the right hand side matrix B. !> On exit, the solution matrix X. !> ``` *LDB* ``` !> LDB is INTEGER !> The leading dimension of the array B. LDB >= max(1,N). !> ``` *WORK* ``` !> WORK is COMPLEX array, dimension (N) !> ``` *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 **125** of file **chetrs2.f**. ### subroutine csytrs2 (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 info) **CSYTRS2** **Purpose:** ``` !> !> CSYTRS2 solves a system of linear equations A*X = B with a complex !> symmetric matrix A using the factorization A = U*D*U**T or !> A = L*D*L**T computed by CSYTRF and converted by CSYCONV. !> ``` **Parameters** *UPLO* ``` !> UPLO is CHARACTER*1 !> Specifies whether the details of the factorization are stored !> as an upper or lower triangular matrix. !> = 'U': Upper triangular, form is A = U*D*U**T; !> = 'L': Lower triangular, form is A = L*D*L**T. !> ``` *N* ``` !> N is INTEGER !> 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) !> The block diagonal matrix D and the multipliers used to !> obtain the factor U or L as computed by CSYTRF. !> Note that A is input / output. This might be counter-intuitive, !> and one may think that A is input only. A is input / output. This !> is because, at the start of the subroutine, we permute A in a !> form and then we permute A back to its original form at !> the end. !> ``` *LDA* ``` !> LDA is INTEGER !> The leading dimension of the array A. LDA >= max(1,N). !> ``` *IPIV* ``` !> IPIV is INTEGER array, dimension (N) !> Details of the interchanges and the block structure of D !> as determined by CSYTRF. !> ``` *B* ``` !> B is COMPLEX array, dimension (LDB,NRHS) !> On entry, the right hand side matrix B. !> On exit, the solution matrix X. !> ``` *LDB* ``` !> LDB is INTEGER !> The leading dimension of the array B. LDB >= max(1,N). !> ``` *WORK* ``` !> WORK is COMPLEX array, dimension (N) !> ``` *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 **130** of file **csytrs2.f**. ### subroutine dsytrs2 (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 info) **DSYTRS2** **Purpose:** ``` !> !> DSYTRS2 solves a system of linear equations A*X = B with a real !> symmetric matrix A using the factorization A = U*D*U**T or !> A = L*D*L**T computed by DSYTRF and converted by DSYCONV. !> ``` **Parameters** *UPLO* ``` !> UPLO is CHARACTER*1 !> Specifies whether the details of the factorization are stored !> as an upper or lower triangular matrix. !> = 'U': Upper triangular, form is A = U*D*U**T; !> = 'L': Lower triangular, form is A = L*D*L**T. !> ``` *N* ``` !> N is INTEGER !> 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) !> The block diagonal matrix D and the multipliers used to !> obtain the factor U or L as computed by DSYTRF. !> Note that A is input / output. This might be counter-intuitive, !> and one may think that A is input only. A is input / output. This !> is because, at the start of the subroutine, we permute A in a !> form and then we permute A back to its original form at !> the end. !> ``` *LDA* ``` !> LDA is INTEGER !> The leading dimension of the array A. LDA >= max(1,N). !> ``` *IPIV* ``` !> IPIV is INTEGER array, dimension (N) !> Details of the interchanges and the block structure of D !> as determined by DSYTRF. !> ``` *B* ``` !> B is DOUBLE PRECISION array, dimension (LDB,NRHS) !> On entry, the right hand side matrix B. !> On exit, the 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 (N) !> ``` *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 **130** of file **dsytrs2.f**. ### subroutine ssytrs2 (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 info) **SSYTRS2** **Purpose:** ``` !> !> SSYTRS2 solves a system of linear equations A*X = B with a real !> symmetric matrix A using the factorization A = U*D*U**T or !> A = L*D*L**T computed by SSYTRF and converted by SSYCONV. !> ``` **Parameters** *UPLO* ``` !> UPLO is CHARACTER*1 !> Specifies whether the details of the factorization are stored !> as an upper or lower triangular matrix. !> = 'U': Upper triangular, form is A = U*D*U**T; !> = 'L': Lower triangular, form is A = L*D*L**T. !> ``` *N* ``` !> N is INTEGER !> 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) !> The block diagonal matrix D and the multipliers used to !> obtain the factor U or L as computed by SSYTRF. !> Note that A is input / output. This might be counter-intuitive, !> and one may think that A is input only. A is input / output. This !> is because, at the start of the subroutine, we permute A in a !> form and then we permute A back to its original form at !> the end. !> ``` *LDA* ``` !> LDA is INTEGER !> The leading dimension of the array A. LDA >= max(1,N). !> ``` *IPIV* ``` !> IPIV is INTEGER array, dimension (N) !> Details of the interchanges and the block structure of D !> as determined by SSYTRF. !> ``` *B* ``` !> B is REAL array, dimension (LDB,NRHS) !> On entry, the right hand side matrix B. !> On exit, the solution matrix X. !> ``` *LDB* ``` !> LDB is INTEGER !> The leading dimension of the array B. LDB >= max(1,N). !> ``` *WORK* ``` !> WORK is REAL array, dimension (N) !> ``` *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 **130** of file **ssytrs2.f**. ### subroutine zhetrs2 (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 info) **ZHETRS2** **Purpose:** ``` !> !> ZHETRS2 solves a system of linear equations A*X = B with a complex !> Hermitian matrix A using the factorization A = U*D*U**H or !> A = L*D*L**H computed by ZHETRF and converted by ZSYCONV. !> ``` **Parameters** *UPLO* ``` !> UPLO is CHARACTER*1 !> Specifies whether the details of the factorization are stored !> as an upper or lower triangular matrix. !> = 'U': Upper triangular, form is A = U*D*U**H; !> = 'L': Lower triangular, form is A = L*D*L**H. !> ``` *N* ``` !> N is INTEGER !> 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) !> The block diagonal matrix D and the multipliers used to !> obtain the factor U or L as computed by ZHETRF. !> ``` *LDA* ``` !> LDA is INTEGER !> The leading dimension of the array A. LDA >= max(1,N). !> ``` *IPIV* ``` !> IPIV is INTEGER array, dimension (N) !> Details of the interchanges and the block structure of D !> as determined by ZHETRF. !> ``` *B* ``` !> B is COMPLEX*16 array, dimension (LDB,NRHS) !> On entry, the right hand side matrix B. !> On exit, the 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 (N) !> ``` *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 **125** of file **zhetrs2.f**. ### subroutine zsytrs2 (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 info) **ZSYTRS2** **Purpose:** ``` !> !> ZSYTRS2 solves a system of linear equations A*X = B with a complex !> symmetric matrix A using the factorization A = U*D*U**T or !> A = L*D*L**T computed by ZSYTRF and converted by ZSYCONV. !> ``` **Parameters** *UPLO* ``` !> UPLO is CHARACTER*1 !> Specifies whether the details of the factorization are stored !> as an upper or lower triangular matrix. !> = 'U': Upper triangular, form is A = U*D*U**T; !> = 'L': Lower triangular, form is A = L*D*L**T. !> ``` *N* ``` !> N is INTEGER !> 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) !> The block diagonal matrix D and the multipliers used to !> obtain the factor U or L as computed by ZSYTRF. !> Note that A is input / output. This might be counter-intuitive, !> and one may think that A is input only. A is input / output. This !> is because, at the start of the subroutine, we permute A in a !> form and then we permute A back to its original form at !> the end. !> ``` *LDA* ``` !> LDA is INTEGER !> The leading dimension of the array A. LDA >= max(1,N). !> ``` *IPIV* ``` !> IPIV is INTEGER array, dimension (N) !> Details of the interchanges and the block structure of D !> as determined by ZSYTRF. !> ``` *B* ``` !> B is COMPLEX*16 array, dimension (LDB,NRHS) !> On entry, the right hand side matrix B. !> On exit, the 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 (N) !> ``` *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 **130** of file **zsytrs2.f**. ## Author Generated automatically by Doxygen for LAPACK from the source code.