zsptri()

subroutine zsptri	(	character	uplo,
		integer	n,
		complex*16, dimension( * )	ap,
		integer, dimension( * )	ipiv,
		complex*16, dimension( * )	work,
		integer	info
	)

ZSPTRI

Download ZSPTRI + dependencies [TGZ] [ZIP] [TXT]

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

[in]	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.
[in]	N	N is INTEGER The order of the matrix A. N >= 0.
[in,out]	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.
[in]	IPIV	IPIV is INTEGER array, dimension (N) Details of the interchanges and the block structure of D as determined by ZSPTRF.
[out]	WORK	WORK is COMPLEX*16 array, dimension (N)
[out]	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.

Definition at line 108 of file zsptri.f.

*
*  -- LAPACK computational routine --
*  -- LAPACK is a software package provided by Univ. of Tennessee,    --
*  -- Univ. of California Berkeley, Univ. of Colorado Denver and NAG Ltd..--
*
*     .. Scalar Arguments ..
      CHARACTER          UPLO
      INTEGER            INFO, N
*     ..
*     .. Array Arguments ..
      INTEGER            IPIV( * )
      COMPLEX*16         AP( * ), WORK( * )
*     ..
*
*  =====================================================================
*
*     .. Parameters ..
      COMPLEX*16         ONE, ZERO
      parameter( one = ( 1.0d+0, 0.0d+0 ),
     $                   zero = ( 0.0d+0, 0.0d+0 ) )
*     ..
*     .. Local Scalars ..
      LOGICAL            UPPER
      INTEGER            J, K, KC, KCNEXT, KP, KPC, KSTEP, KX, NPP
      COMPLEX*16         AK, AKKP1, AKP1, D, T, TEMP
*     ..
*     .. External Functions ..
      LOGICAL            LSAME
      COMPLEX*16         ZDOTU
      EXTERNAL           lsame, zdotu
*     ..
*     .. External Subroutines ..
      EXTERNAL           xerbla, zcopy, zspmv, zswap
*     ..
*     .. Intrinsic Functions ..
      INTRINSIC          abs
*     ..
*     .. Executable Statements ..
*
*     Test the input parameters.
*
      info = 0
      upper = lsame( uplo, 'U' )
      IF( .NOT.upper .AND. .NOT.lsame( uplo, 'L' ) ) THEN
         info = -1
      ELSE IF( n.LT.0 ) THEN
         info = -2
      END IF
      IF( info.NE.0 ) THEN
         CALL xerbla( 'ZSPTRI', -info )
         RETURN
      END IF
*
*     Quick return if possible
*
      IF( n.EQ.0 )
     $   RETURN
*
*     Check that the diagonal matrix D is nonsingular.
*
      IF( upper ) THEN
*
*        Upper triangular storage: examine D from bottom to top
*
         kp = n*( n+1 ) / 2
         DO 10 info = n, 1, -1
            IF( ipiv( info ).GT.0 .AND. ap( kp ).EQ.zero )
     $         RETURN
            kp = kp - info
   10    CONTINUE
      ELSE
*
*        Lower triangular storage: examine D from top to bottom.
*
         kp = 1
         DO 20 info = 1, n
            IF( ipiv( info ).GT.0 .AND. ap( kp ).EQ.zero )
     $         RETURN
            kp = kp + n - info + 1
   20    CONTINUE
      END IF
      info = 0
*
      IF( upper ) THEN
*
*        Compute inv(A) from the factorization A = U*D*U**T.
*
*        K is the main loop index, increasing from 1 to N in steps of
*        1 or 2, depending on the size of the diagonal blocks.
*
         k = 1
         kc = 1
   30    CONTINUE
*
*        If K > N, exit from loop.
*
         IF( k.GT.n )
     $      GO TO 50
*
         kcnext = kc + k
         IF( ipiv( k ).GT.0 ) THEN
*
*           1 x 1 diagonal block
*
*           Invert the diagonal block.
*
            ap( kc+k-1 ) = one / ap( kc+k-1 )
*
*           Compute column K of the inverse.
*
            IF( k.GT.1 ) THEN
               CALL zcopy( k-1, ap( kc ), 1, work, 1 )
               CALL zspmv( uplo, k-1, -one, ap, work, 1, zero, ap( kc ),
     $                     1 )
               ap( kc+k-1 ) = ap( kc+k-1 ) -
     $                        zdotu( k-1, work, 1, ap( kc ), 1 )
            END IF
            kstep = 1
         ELSE
*
*           2 x 2 diagonal block
*
*           Invert the diagonal block.
*
            t = ap( kcnext+k-1 )
            ak = ap( kc+k-1 ) / t
            akp1 = ap( kcnext+k ) / t
            akkp1 = ap( kcnext+k-1 ) / t
            d = t*( ak*akp1-one )
            ap( kc+k-1 ) = akp1 / d
            ap( kcnext+k ) = ak / d
            ap( kcnext+k-1 ) = -akkp1 / d
*
*           Compute columns K and K+1 of the inverse.
*
            IF( k.GT.1 ) THEN
               CALL zcopy( k-1, ap( kc ), 1, work, 1 )
               CALL zspmv( uplo, k-1, -one, ap, work, 1, zero, ap( kc ),
     $                     1 )
               ap( kc+k-1 ) = ap( kc+k-1 ) -
     $                        zdotu( k-1, work, 1, ap( kc ), 1 )
               ap( kcnext+k-1 ) = ap( kcnext+k-1 ) -
     $                            zdotu( k-1, ap( kc ), 1, ap( kcnext ),
     $                            1 )
               CALL zcopy( k-1, ap( kcnext ), 1, work, 1 )
               CALL zspmv( uplo, k-1, -one, ap, work, 1, zero,
     $                     ap( kcnext ), 1 )
               ap( kcnext+k ) = ap( kcnext+k ) -
     $                          zdotu( k-1, work, 1, ap( kcnext ), 1 )
            END IF
            kstep = 2
            kcnext = kcnext + k + 1
         END IF
*
         kp = abs( ipiv( k ) )
         IF( kp.NE.k ) THEN
*
*           Interchange rows and columns K and KP in the leading
*           submatrix A(1:k+1,1:k+1)
*
            kpc = ( kp-1 )*kp / 2 + 1
            CALL zswap( kp-1, ap( kc ), 1, ap( kpc ), 1 )
            kx = kpc + kp - 1
            DO 40 j = kp + 1, k - 1
               kx = kx + j - 1
               temp = ap( kc+j-1 )
               ap( kc+j-1 ) = ap( kx )
               ap( kx ) = temp
   40       CONTINUE
            temp = ap( kc+k-1 )
            ap( kc+k-1 ) = ap( kpc+kp-1 )
            ap( kpc+kp-1 ) = temp
            IF( kstep.EQ.2 ) THEN
               temp = ap( kc+k+k-1 )
               ap( kc+k+k-1 ) = ap( kc+k+kp-1 )
               ap( kc+k+kp-1 ) = temp
            END IF
         END IF
*
         k = k + kstep
         kc = kcnext
         GO TO 30
   50    CONTINUE
*
      ELSE
*
*        Compute inv(A) from the factorization A = L*D*L**T.
*
*        K is the main loop index, increasing from 1 to N in steps of
*        1 or 2, depending on the size of the diagonal blocks.
*
         npp = n*( n+1 ) / 2
         k = n
         kc = npp
   60    CONTINUE
*
*        If K < 1, exit from loop.
*
         IF( k.LT.1 )
     $      GO TO 80
*
         kcnext = kc - ( n-k+2 )
         IF( ipiv( k ).GT.0 ) THEN
*
*           1 x 1 diagonal block
*
*           Invert the diagonal block.
*
            ap( kc ) = one / ap( kc )
*
*           Compute column K of the inverse.
*
            IF( k.LT.n ) THEN
               CALL zcopy( n-k, ap( kc+1 ), 1, work, 1 )
               CALL zspmv( uplo, n-k, -one, ap( kc+n-k+1 ), work, 1,
     $                     zero, ap( kc+1 ), 1 )
               ap( kc ) = ap( kc ) - zdotu( n-k, work, 1, ap( kc+1 ),
     $                    1 )
            END IF
            kstep = 1
         ELSE
*
*           2 x 2 diagonal block
*
*           Invert the diagonal block.
*
            t = ap( kcnext+1 )
            ak = ap( kcnext ) / t
            akp1 = ap( kc ) / t
            akkp1 = ap( kcnext+1 ) / t
            d = t*( ak*akp1-one )
            ap( kcnext ) = akp1 / d
            ap( kc ) = ak / d
            ap( kcnext+1 ) = -akkp1 / d
*
*           Compute columns K-1 and K of the inverse.
*
            IF( k.LT.n ) THEN
               CALL zcopy( n-k, ap( kc+1 ), 1, work, 1 )
               CALL zspmv( uplo, n-k, -one, ap( kc+( n-k+1 ) ), work, 1,
     $                     zero, ap( kc+1 ), 1 )
               ap( kc ) = ap( kc ) - zdotu( n-k, work, 1, ap( kc+1 ),
     $                    1 )
               ap( kcnext+1 ) = ap( kcnext+1 ) -
     $                          zdotu( n-k, ap( kc+1 ), 1,
     $                          ap( kcnext+2 ), 1 )
               CALL zcopy( n-k, ap( kcnext+2 ), 1, work, 1 )
               CALL zspmv( uplo, n-k, -one, ap( kc+( n-k+1 ) ), work, 1,
     $                     zero, ap( kcnext+2 ), 1 )
               ap( kcnext ) = ap( kcnext ) -
     $                        zdotu( n-k, work, 1, ap( kcnext+2 ), 1 )
            END IF
            kstep = 2
            kcnext = kcnext - ( n-k+3 )
         END IF
*
         kp = abs( ipiv( k ) )
         IF( kp.NE.k ) THEN
*
*           Interchange rows and columns K and KP in the trailing
*           submatrix A(k-1:n,k-1:n)
*
            kpc = npp - ( n-kp+1 )*( n-kp+2 ) / 2 + 1
            IF( kp.LT.n )
     $         CALL zswap( n-kp, ap( kc+kp-k+1 ), 1, ap( kpc+1 ), 1 )
            kx = kc + kp - k
            DO 70 j = k + 1, kp - 1
               kx = kx + n - j + 1
               temp = ap( kc+j-k )
               ap( kc+j-k ) = ap( kx )
               ap( kx ) = temp
   70       CONTINUE
            temp = ap( kc )
            ap( kc ) = ap( kpc )
            ap( kpc ) = temp
            IF( kstep.EQ.2 ) THEN
               temp = ap( kc-n+k-1 )
               ap( kc-n+k-1 ) = ap( kc-n+kp-1 )
               ap( kc-n+kp-1 ) = temp
            END IF
         END IF
*
         k = k - kstep
         kc = kcnext
         GO TO 60
   80    CONTINUE
      END IF
*
      RETURN
*
*     End of ZSPTRI
*

Here is the call graph for this function:

Here is the caller graph for this function: