Provided by: liblapack-doc_3.12.0-3build1.1_all 
      
    
NAME
       hetrs_rook - {he,sy}trs_rook: triangular solve using factor
SYNOPSIS
   Functions
       subroutine chetrs_rook (uplo, n, nrhs, a, lda, ipiv, b, ldb, info)
           CHETRS_ROOK computes the solution to a system of linear equations A * X = B for HE matrices using
           factorization obtained with one of the bounded diagonal pivoting methods (max 2 interchanges)
       subroutine csytrs_rook (uplo, n, nrhs, a, lda, ipiv, b, ldb, info)
           CSYTRS_ROOK
       subroutine dsytrs_rook (uplo, n, nrhs, a, lda, ipiv, b, ldb, info)
           DSYTRS_ROOK
       subroutine ssytrs_rook (uplo, n, nrhs, a, lda, ipiv, b, ldb, info)
           SSYTRS_ROOK
       subroutine zhetrs_rook (uplo, n, nrhs, a, lda, ipiv, b, ldb, info)
           ZHETRS_ROOK computes the solution to a system of linear equations A * X = B for HE matrices using
           factorization obtained with one of the bounded diagonal pivoting methods (max 2 interchanges)
       subroutine zsytrs_rook (uplo, n, nrhs, a, lda, ipiv, b, ldb, info)
           ZSYTRS_ROOK
Detailed Description
Function Documentation
   subroutine chetrs_rook (character uplo, integer n, integer nrhs, complex, dimension( lda, * ) a, integer lda,
       integer, dimension( * ) ipiv, complex, dimension( ldb, * ) b, integer ldb, integer info)
       CHETRS_ROOK computes the solution to a system of linear equations A * X = B for HE matrices using
       factorization obtained with one of the bounded diagonal pivoting methods (max 2 interchanges)
       Purpose:
            CHETRS_ROOK solves a system of linear equations A*X = B with a complex
            Hermitian matrix A using the factorization A = U*D*U**H or
            A = L*D*L**H computed by CHETRF_ROOK.
       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_ROOK.
           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_ROOK.
           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).
           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.
       Contributors:
             November 2013,  Igor Kozachenko,
                             Computer Science Division,
                             University of California, Berkeley
             September 2007, Sven Hammarling, Nicholas J. Higham, Craig Lucas,
                             School of Mathematics,
                             University of Manchester
   subroutine csytrs_rook (character uplo, integer n, integer nrhs, complex, dimension( lda, * ) a, integer lda,
       integer, dimension( * ) ipiv, complex, dimension( ldb, * ) b, integer ldb, integer info)
       CSYTRS_ROOK
       Purpose:
            CSYTRS_ROOK solves a system of linear equations A*X = B with
            a complex symmetric matrix A using the factorization A = U*D*U**T or
            A = L*D*L**T computed by CSYTRF_ROOK.
       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_ROOK.
           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_ROOK.
           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).
           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.
       Contributors:
              December 2016, Igor Kozachenko,
                             Computer Science Division,
                             University of California, Berkeley
             September 2007, Sven Hammarling, Nicholas J. Higham, Craig Lucas,
                             School of Mathematics,
                             University of Manchester
   subroutine dsytrs_rook (character uplo, integer n, integer nrhs, double precision, dimension( lda, * ) a,
       integer lda, integer, dimension( * ) ipiv, double precision, dimension( ldb, * ) b, integer ldb, integer
       info)
       DSYTRS_ROOK
       Purpose:
            DSYTRS_ROOK 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_ROOK.
       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_ROOK.
           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_ROOK.
           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).
           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.
       Contributors:
              April 2012, Igor Kozachenko,
                             Computer Science Division,
                             University of California, Berkeley
             September 2007, Sven Hammarling, Nicholas J. Higham, Craig Lucas,
                             School of Mathematics,
                             University of Manchester
   subroutine ssytrs_rook (character uplo, integer n, integer nrhs, real, dimension( lda, * ) a, integer lda,
       integer, dimension( * ) ipiv, real, dimension( ldb, * ) b, integer ldb, integer info)
       SSYTRS_ROOK
       Purpose:
            SSYTRS_ROOK 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_ROOK.
       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_ROOK.
           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_ROOK.
           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).
           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.
       Contributors:
              April 2012, Igor Kozachenko,
                             Computer Science Division,
                             University of California, Berkeley
             September 2007, Sven Hammarling, Nicholas J. Higham, Craig Lucas,
                             School of Mathematics,
                             University of Manchester
   subroutine zhetrs_rook (character uplo, integer n, integer nrhs, complex*16, dimension( lda, * ) a, integer
       lda, integer, dimension( * ) ipiv, complex*16, dimension( ldb, * ) b, integer ldb, integer info)
       ZHETRS_ROOK computes the solution to a system of linear equations A * X = B for HE matrices using
       factorization obtained with one of the bounded diagonal pivoting methods (max 2 interchanges)
       Purpose:
            ZHETRS_ROOK solves a system of linear equations A*X = B with a complex
            Hermitian matrix A using the factorization A = U*D*U**H or
            A = L*D*L**H computed by ZHETRF_ROOK.
       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_ROOK.
           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_ROOK.
           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).
           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.
       Contributors:
             November 2013,  Igor Kozachenko,
                             Computer Science Division,
                             University of California, Berkeley
             September 2007, Sven Hammarling, Nicholas J. Higham, Craig Lucas,
                             School of Mathematics,
                             University of Manchester
   subroutine zsytrs_rook (character uplo, integer n, integer nrhs, complex*16, dimension( lda, * ) a, integer
       lda, integer, dimension( * ) ipiv, complex*16, dimension( ldb, * ) b, integer ldb, integer info)
       ZSYTRS_ROOK
       Purpose:
            ZSYTRS_ROOK solves a system of linear equations A*X = B with
            a complex symmetric matrix A using the factorization A = U*D*U**T or
            A = L*D*L**T computed by ZSYTRF_ROOK.
       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_ROOK.
           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_ROOK.
           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).
           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.
       Contributors:
              December 2016, Igor Kozachenko,
                             Computer Science Division,
                             University of California, Berkeley
             September 2007, Sven Hammarling, Nicholas J. Higham, Craig Lucas,
                             School of Mathematics,
                             University of Manchester
Author
       Generated automatically by Doxygen for LAPACK from the source code.
Version 3.12.0                               Fri Aug 9 2024 02:33:22                               hetrs_rook(3)