Provided by: liblapack-doc_3.12.0-3build1.1_all 
      
    
NAME
       hptri - {hp,sp}tri: triangular inverse
SYNOPSIS
   Functions
       subroutine chptri (uplo, n, ap, ipiv, work, info)
           CHPTRI
       subroutine csptri (uplo, n, ap, ipiv, work, info)
           CSPTRI
       subroutine dsptri (uplo, n, ap, ipiv, work, info)
           DSPTRI
       subroutine ssptri (uplo, n, ap, ipiv, work, info)
           SSPTRI
       subroutine zhptri (uplo, n, ap, ipiv, work, info)
           ZHPTRI
       subroutine zsptri (uplo, n, ap, ipiv, work, info)
           ZSPTRI
Detailed Description
Function Documentation
   subroutine chptri (character uplo, integer n, complex, dimension( * ) ap, integer, dimension( * ) ipiv,
       complex, dimension( * ) work, integer info)
       CHPTRI
       Purpose:
            CHPTRI computes the inverse of a complex Hermitian indefinite matrix
            A in packed storage using the factorization A = U*D*U**H or
            A = L*D*L**H computed by CHPTRF.
       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.
           AP
                     AP is COMPLEX array, dimension (N*(N+1)/2)
                     On entry, the block diagonal matrix D and the multipliers
                     used to obtain the factor U or L as computed by CHPTRF,
                     stored as a packed triangular matrix.
                     On exit, if INFO = 0, the (Hermitian) inverse of the original
                     matrix, stored as a packed triangular matrix. The j-th column
                     of inv(A) is stored in the array AP as follows:
                     if UPLO = 'U', AP(i + (j-1)*j/2) = inv(A)(i,j) for 1<=i<=j;
                     if UPLO = 'L',
                        AP(i + (j-1)*(2n-j)/2) = inv(A)(i,j) for j<=i<=n.
           IPIV
                     IPIV is INTEGER array, dimension (N)
                     Details of the interchanges and the block structure of D
                     as determined by CHPTRF.
           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.
   subroutine csptri (character uplo, integer n, complex, dimension( * ) ap, integer, dimension( * ) ipiv,
       complex, dimension( * ) work, integer info)
       CSPTRI
       Purpose:
            CSPTRI computes the inverse of a complex symmetric indefinite matrix
            A in packed storage using the factorization A = U*D*U**T or
            A = L*D*L**T computed by CSPTRF.
       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.
           AP
                     AP is COMPLEX array, dimension (N*(N+1)/2)
                     On entry, the block diagonal matrix D and the multipliers
                     used to obtain the factor U or L as computed by CSPTRF,
                     stored as a packed triangular matrix.
                     On exit, if INFO = 0, the (symmetric) inverse of the original
                     matrix, stored as a packed triangular matrix. The j-th column
                     of inv(A) is stored in the array AP as follows:
                     if UPLO = 'U', AP(i + (j-1)*j/2) = inv(A)(i,j) for 1<=i<=j;
                     if UPLO = 'L',
                        AP(i + (j-1)*(2n-j)/2) = inv(A)(i,j) for j<=i<=n.
           IPIV
                     IPIV is INTEGER array, dimension (N)
                     Details of the interchanges and the block structure of D
                     as determined by CSPTRF.
           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.
   subroutine dsptri (character uplo, integer n, double precision, dimension( * ) ap, integer, dimension( * )
       ipiv, double precision, dimension( * ) work, integer info)
       DSPTRI
       Purpose:
            DSPTRI computes the inverse of a real symmetric indefinite matrix
            A in packed storage using the factorization A = U*D*U**T or
            A = L*D*L**T computed by DSPTRF.
       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.
           AP
                     AP is DOUBLE PRECISION array, dimension (N*(N+1)/2)
                     On entry, the block diagonal matrix D and the multipliers
                     used to obtain the factor U or L as computed by DSPTRF,
                     stored as a packed triangular matrix.
                     On exit, if INFO = 0, the (symmetric) inverse of the original
                     matrix, stored as a packed triangular matrix. The j-th column
                     of inv(A) is stored in the array AP as follows:
                     if UPLO = 'U', AP(i + (j-1)*j/2) = inv(A)(i,j) for 1<=i<=j;
                     if UPLO = 'L',
                        AP(i + (j-1)*(2n-j)/2) = inv(A)(i,j) for j<=i<=n.
           IPIV
                     IPIV is INTEGER array, dimension (N)
                     Details of the interchanges and the block structure of D
                     as determined by DSPTRF.
           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.
   subroutine ssptri (character uplo, integer n, real, dimension( * ) ap, integer, dimension( * ) ipiv, real,
       dimension( * ) work, integer info)
       SSPTRI
       Purpose:
            SSPTRI computes the inverse of a real symmetric indefinite matrix
            A in packed storage using the factorization A = U*D*U**T or
            A = L*D*L**T computed by SSPTRF.
       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.
           AP
                     AP is REAL array, dimension (N*(N+1)/2)
                     On entry, the block diagonal matrix D and the multipliers
                     used to obtain the factor U or L as computed by SSPTRF,
                     stored as a packed triangular matrix.
                     On exit, if INFO = 0, the (symmetric) inverse of the original
                     matrix, stored as a packed triangular matrix. The j-th column
                     of inv(A) is stored in the array AP as follows:
                     if UPLO = 'U', AP(i + (j-1)*j/2) = inv(A)(i,j) for 1<=i<=j;
                     if UPLO = 'L',
                        AP(i + (j-1)*(2n-j)/2) = inv(A)(i,j) for j<=i<=n.
           IPIV
                     IPIV is INTEGER array, dimension (N)
                     Details of the interchanges and the block structure of D
                     as determined by SSPTRF.
           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.
   subroutine zhptri (character uplo, integer n, complex*16, dimension( * ) ap, integer, dimension( * ) ipiv,
       complex*16, dimension( * ) work, integer info)
       ZHPTRI
       Purpose:
            ZHPTRI computes the inverse of a complex Hermitian indefinite matrix
            A in packed storage using the factorization A = U*D*U**H or
            A = L*D*L**H computed by ZHPTRF.
       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.
           AP
                     AP is COMPLEX*16 array, dimension (N*(N+1)/2)
                     On entry, the block diagonal matrix D and the multipliers
                     used to obtain the factor U or L as computed by ZHPTRF,
                     stored as a packed triangular matrix.
                     On exit, if INFO = 0, the (Hermitian) inverse of the original
                     matrix, stored as a packed triangular matrix. The j-th column
                     of inv(A) is stored in the array AP as follows:
                     if UPLO = 'U', AP(i + (j-1)*j/2) = inv(A)(i,j) for 1<=i<=j;
                     if UPLO = 'L',
                        AP(i + (j-1)*(2n-j)/2) = inv(A)(i,j) for j<=i<=n.
           IPIV
                     IPIV is INTEGER array, dimension (N)
                     Details of the interchanges and the block structure of D
                     as determined by ZHPTRF.
           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.
   subroutine zsptri (character uplo, integer n, complex*16, dimension( * ) ap, integer, dimension( * ) ipiv,
       complex*16, dimension( * ) work, integer info)
       ZSPTRI
       Purpose:
            ZSPTRI computes the inverse of a complex symmetric indefinite matrix
            A in packed storage using the factorization A = U*D*U**T or
            A = L*D*L**T computed by ZSPTRF.
       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.
           AP
                     AP is COMPLEX*16 array, dimension (N*(N+1)/2)
                     On entry, the block diagonal matrix D and the multipliers
                     used to obtain the factor U or L as computed by ZSPTRF,
                     stored as a packed triangular matrix.
                     On exit, if INFO = 0, the (symmetric) inverse of the original
                     matrix, stored as a packed triangular matrix. The j-th column
                     of inv(A) is stored in the array AP as follows:
                     if UPLO = 'U', AP(i + (j-1)*j/2) = inv(A)(i,j) for 1<=i<=j;
                     if UPLO = 'L',
                        AP(i + (j-1)*(2n-j)/2) = inv(A)(i,j) for j<=i<=n.
           IPIV
                     IPIV is INTEGER array, dimension (N)
                     Details of the interchanges and the block structure of D
                     as determined by ZSPTRF.
           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.
Author
       Generated automatically by Doxygen for LAPACK from the source code.
Version 3.12.0                               Fri Aug 9 2024 02:33:22                                    hptri(3)