hetri_rook(3)

NAME
hetri_rook - {he,sy}tri_rook: triangular inverse

SYNOPSIS

  Functions

subroutine chetri_rook (uplo, n, a, lda, ipiv, work, info)
CHETRI_ROOK computes the inverse of HE matrix using the factorization obtained with the bounded Bunch-Kaufman (rook")diagonalpivotingmethod.
subroutine csytri_rook (uplo, n, a, lda, ipiv, work, info)
CSYTRI_ROOK
subroutine dsytri_rook (uplo, n, a, lda, ipiv, work, info)
DSYTRI_ROOK
subroutine ssytri_rook (uplo, n, a, lda, ipiv, work, info)
SSYTRI_ROOK
subroutine zhetri_rook (uplo, n, a, lda, ipiv, work, info)
ZHETRI_ROOK computes the inverse of HE matrix using the factorization obtained with the bounded Bunch-Kaufman (rook")diagonalpivotingmethod.
subroutine zsytri_rook (uplo, n, a, lda, ipiv, work, info)
ZSYTRI_ROOK

Detailed Description

Function Documentation

  subroutine chetri_rook (character uplo, integer n, complex, dimension( lda, * ) a, integer lda, integer, dimension( * ) ipiv, complex, dimension( * ) work, integer info)

CHETRI_ROOK computes the inverse of HE matrix using the factorization obtained with the bounded Bunch-Kaufman ("rook") diagonal pivoting method.

Purpose:

    !>
    !> CHETRI_ROOK computes the inverse of a complex Hermitian indefinite 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.
    !>

    A

    !>          A is COMPLEX array, dimension (LDA,N)
    !>          On entry, the block diagonal matrix D and the multipliers
    !>          used to obtain the factor U or L as computed by CHETRF_ROOK.
    !>
    !>          On exit, if INFO = 0, the (Hermitian) inverse of the original
    !>          matrix.  If UPLO = 'U', the upper triangular part of the
    !>          inverse is formed and the part of A below the diagonal is not
    !>          referenced; if UPLO = 'L' the lower triangular part of the
    !>          inverse is formed and the part of A above the diagonal is
    !>          not referenced.
    !>

    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.
    !>

    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
    !>          > 0: if INFO = i, D(i,i) = 0; the matrix is singular and its
    !>               inverse could not be computed.
    !>

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 csytri_rook (character uplo, integer n, complex, dimension( lda, * ) a, integer lda, integer, dimension( * ) ipiv, complex, dimension( * ) work, integer info)

CSYTRI_ROOK

Purpose:

    !>
    !> CSYTRI_ROOK computes the inverse of 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.
    !>

    A

    !>          A is COMPLEX array, dimension (LDA,N)
    !>          On entry, the block diagonal matrix D and the multipliers
    !>          used to obtain the factor U or L as computed by CSYTRF_ROOK.
    !>
    !>          On exit, if INFO = 0, the (symmetric) inverse of the original
    !>          matrix.  If UPLO = 'U', the upper triangular part of the
    !>          inverse is formed and the part of A below the diagonal is not
    !>          referenced; if UPLO = 'L' the lower triangular part of the
    !>          inverse is formed and the part of A above the diagonal is
    !>          not referenced.
    !>

    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.
    !>

    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
    !>          > 0: if INFO = i, D(i,i) = 0; the matrix is singular and its
    !>               inverse could not be computed.
    !>

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 dsytri_rook (character uplo, integer n, double precision, dimension( lda, * ) a, integer lda, integer, dimension( * ) ipiv, double precision, dimension( * ) work, integer info)

DSYTRI_ROOK

Purpose:

    !>
    !> DSYTRI_ROOK computes the inverse of 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.
    !>

    A

    !>          A is DOUBLE PRECISION array, dimension (LDA,N)
    !>          On entry, the block diagonal matrix D and the multipliers
    !>          used to obtain the factor U or L as computed by DSYTRF_ROOK.
    !>
    !>          On exit, if INFO = 0, the (symmetric) inverse of the original
    !>          matrix.  If UPLO = 'U', the upper triangular part of the
    !>          inverse is formed and the part of A below the diagonal is not
    !>          referenced; if UPLO = 'L' the lower triangular part of the
    !>          inverse is formed and the part of A above the diagonal is
    !>          not referenced.
    !>

    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.
    !>

    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
    !>          > 0: if INFO = i, D(i,i) = 0; the matrix is singular and its
    !>               inverse could not be computed.
    !>

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 ssytri_rook (character uplo, integer n, real, dimension( lda, * ) a, integer lda, integer, dimension( * ) ipiv, real, dimension( * ) work, integer info)

SSYTRI_ROOK

Purpose:

    !>
    !> SSYTRI_ROOK computes the inverse of 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.
    !>

    A

    !>          A is REAL array, dimension (LDA,N)
    !>          On entry, the block diagonal matrix D and the multipliers
    !>          used to obtain the factor U or L as computed by SSYTRF_ROOK.
    !>
    !>          On exit, if INFO = 0, the (symmetric) inverse of the original
    !>          matrix.  If UPLO = 'U', the upper triangular part of the
    !>          inverse is formed and the part of A below the diagonal is not
    !>          referenced; if UPLO = 'L' the lower triangular part of the
    !>          inverse is formed and the part of A above the diagonal is
    !>          not referenced.
    !>

    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.
    !>

    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
    !>          > 0: if INFO = i, D(i,i) = 0; the matrix is singular and its
    !>               inverse could not be computed.
    !>

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 zhetri_rook (character uplo, integer n, complex*16, dimension( lda, * ) a, integer lda, integer, dimension( * ) ipiv, complex*16, dimension( * ) work, integer info)

ZHETRI_ROOK computes the inverse of HE matrix using the factorization obtained with the bounded Bunch-Kaufman ("rook") diagonal pivoting method.

Purpose:

    !>
    !> ZHETRI_ROOK computes the inverse of a complex Hermitian indefinite 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.
    !>

    A

    !>          A is COMPLEX*16 array, dimension (LDA,N)
    !>          On entry, the block diagonal matrix D and the multipliers
    !>          used to obtain the factor U or L as computed by ZHETRF_ROOK.
    !>
    !>          On exit, if INFO = 0, the (Hermitian) inverse of the original
    !>          matrix.  If UPLO = 'U', the upper triangular part of the
    !>          inverse is formed and the part of A below the diagonal is not
    !>          referenced; if UPLO = 'L' the lower triangular part of the
    !>          inverse is formed and the part of A above the diagonal is
    !>          not referenced.
    !>

    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.
    !>

    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
    !>          > 0: if INFO = i, D(i,i) = 0; the matrix is singular and its
    !>               inverse could not be computed.
    !>

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 zsytri_rook (character uplo, integer n, complex*16, dimension( lda, * ) a, integer lda, integer, dimension( * ) ipiv, complex*16, dimension( * ) work, integer info)

ZSYTRI_ROOK

Purpose:

    !>
    !> ZSYTRI_ROOK computes the inverse of 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.
    !>

    A

    !>          A is COMPLEX*16 array, dimension (LDA,N)
    !>          On entry, the block diagonal matrix D and the multipliers
    !>          used to obtain the factor U or L as computed by ZSYTRF_ROOK.
    !>
    !>          On exit, if INFO = 0, the (symmetric) inverse of the original
    !>          matrix.  If UPLO = 'U', the upper triangular part of the
    !>          inverse is formed and the part of A below the diagonal is not
    !>          referenced; if UPLO = 'L' the lower triangular part of the
    !>          inverse is formed and the part of A above the diagonal is
    !>          not referenced.
    !>

    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.
    !>

    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
    !>          > 0: if INFO = i, D(i,i) = 0; the matrix is singular and its
    !>               inverse could not be computed.
    !>

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.