zsytri()

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

ZSYTRI

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

Purpose:

 ZSYTRI computes the inverse of a complex symmetric indefinite matrix
 A using the factorization A = U*D*U**T or A = L*D*L**T computed by
 ZSYTRF.

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]	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. 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.
[in]	LDA	LDA is INTEGER The leading dimension of the array A. LDA >= max(1,N).
[in]	IPIV	IPIV is INTEGER array, dimension (N) Details of the interchanges and the block structure of D as determined by ZSYTRF.
[out]	WORK	WORK is COMPLEX*16 array, dimension (2*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 113 of file zsytri.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, LDA, N
*     ..
*     .. Array Arguments ..
      INTEGER            IPIV( * )
      COMPLEX*16         A( LDA, * ), 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            K, KP, KSTEP
      COMPLEX*16         AK, AKKP1, AKP1, D, T, TEMP
*     ..
*     .. External Functions ..
      LOGICAL            LSAME
      COMPLEX*16         ZDOTU
      EXTERNAL           lsame, zdotu
*     ..
*     .. External Subroutines ..
      EXTERNAL           xerbla, zcopy, zswap, zsymv
*     ..
*     .. Intrinsic Functions ..
      INTRINSIC          abs, max
*     ..
*     .. 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
      ELSE IF( lda.LT.max( 1, n ) ) THEN
         info = -4
      END IF
      IF( info.NE.0 ) THEN
         CALL xerbla( 'ZSYTRI', -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
*
         DO 10 info = n, 1, -1
            IF( ipiv( info ).GT.0 .AND. a( info, info ).EQ.zero )
     $         RETURN
   10    CONTINUE
      ELSE
*
*        Lower triangular storage: examine D from top to bottom.
*
         DO 20 info = 1, n
            IF( ipiv( info ).GT.0 .AND. a( info, info ).EQ.zero )
     $         RETURN
   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
   30    CONTINUE
*
*        If K > N, exit from loop.
*
         IF( k.GT.n )
     $      GO TO 40
*
         IF( ipiv( k ).GT.0 ) THEN
*
*           1 x 1 diagonal block
*
*           Invert the diagonal block.
*
            a( k, k ) = one / a( k, k )
*
*           Compute column K of the inverse.
*
            IF( k.GT.1 ) THEN
               CALL zcopy( k-1, a( 1, k ), 1, work, 1 )
               CALL zsymv( uplo, k-1, -one, a, lda, work, 1, zero,
     $                     a( 1, k ), 1 )
               a( k, k ) = a( k, k ) - zdotu( k-1, work, 1, a( 1, k ),
     $                     1 )
            END IF
            kstep = 1
         ELSE
*
*           2 x 2 diagonal block
*
*           Invert the diagonal block.
*
            t = a( k, k+1 )
            ak = a( k, k ) / t
            akp1 = a( k+1, k+1 ) / t
            akkp1 = a( k, k+1 ) / t
            d = t*( ak*akp1-one )
            a( k, k ) = akp1 / d
            a( k+1, k+1 ) = ak / d
            a( k, k+1 ) = -akkp1 / d
*
*           Compute columns K and K+1 of the inverse.
*
            IF( k.GT.1 ) THEN
               CALL zcopy( k-1, a( 1, k ), 1, work, 1 )
               CALL zsymv( uplo, k-1, -one, a, lda, work, 1, zero,
     $                     a( 1, k ), 1 )
               a( k, k ) = a( k, k ) - zdotu( k-1, work, 1, a( 1, k ),
     $                     1 )
               a( k, k+1 ) = a( k, k+1 ) -
     $                       zdotu( k-1, a( 1, k ), 1, a( 1, k+1 ), 1 )
               CALL zcopy( k-1, a( 1, k+1 ), 1, work, 1 )
               CALL zsymv( uplo, k-1, -one, a, lda, work, 1, zero,
     $                     a( 1, k+1 ), 1 )
               a( k+1, k+1 ) = a( k+1, k+1 ) -
     $                         zdotu( k-1, work, 1, a( 1, k+1 ), 1 )
            END IF
            kstep = 2
         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)
*
            CALL zswap( kp-1, a( 1, k ), 1, a( 1, kp ), 1 )
            CALL zswap( k-kp-1, a( kp+1, k ), 1, a( kp, kp+1 ), lda )
            temp = a( k, k )
            a( k, k ) = a( kp, kp )
            a( kp, kp ) = temp
            IF( kstep.EQ.2 ) THEN
               temp = a( k, k+1 )
               a( k, k+1 ) = a( kp, k+1 )
               a( kp, k+1 ) = temp
            END IF
         END IF
*
         k = k + kstep
         GO TO 30
   40    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.
*
         k = n
   50    CONTINUE
*
*        If K < 1, exit from loop.
*
         IF( k.LT.1 )
     $      GO TO 60
*
         IF( ipiv( k ).GT.0 ) THEN
*
*           1 x 1 diagonal block
*
*           Invert the diagonal block.
*
            a( k, k ) = one / a( k, k )
*
*           Compute column K of the inverse.
*
            IF( k.LT.n ) THEN
               CALL zcopy( n-k, a( k+1, k ), 1, work, 1 )
               CALL zsymv( uplo, n-k, -one, a( k+1, k+1 ), lda, work, 1,
     $                     zero, a( k+1, k ), 1 )
               a( k, k ) = a( k, k ) - zdotu( n-k, work, 1, a( k+1, k ),
     $                     1 )
            END IF
            kstep = 1
         ELSE
*
*           2 x 2 diagonal block
*
*           Invert the diagonal block.
*
            t = a( k, k-1 )
            ak = a( k-1, k-1 ) / t
            akp1 = a( k, k ) / t
            akkp1 = a( k, k-1 ) / t
            d = t*( ak*akp1-one )
            a( k-1, k-1 ) = akp1 / d
            a( k, k ) = ak / d
            a( k, k-1 ) = -akkp1 / d
*
*           Compute columns K-1 and K of the inverse.
*
            IF( k.LT.n ) THEN
               CALL zcopy( n-k, a( k+1, k ), 1, work, 1 )
               CALL zsymv( uplo, n-k, -one, a( k+1, k+1 ), lda, work, 1,
     $                     zero, a( k+1, k ), 1 )
               a( k, k ) = a( k, k ) - zdotu( n-k, work, 1, a( k+1, k ),
     $                     1 )
               a( k, k-1 ) = a( k, k-1 ) -
     $                       zdotu( n-k, a( k+1, k ), 1, a( k+1, k-1 ),
     $                       1 )
               CALL zcopy( n-k, a( k+1, k-1 ), 1, work, 1 )
               CALL zsymv( uplo, n-k, -one, a( k+1, k+1 ), lda, work, 1,
     $                     zero, a( k+1, k-1 ), 1 )
               a( k-1, k-1 ) = a( k-1, k-1 ) -
     $                         zdotu( n-k, work, 1, a( k+1, k-1 ), 1 )
            END IF
            kstep = 2
         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)
*
            IF( kp.LT.n )
     $         CALL zswap( n-kp, a( kp+1, k ), 1, a( kp+1, kp ), 1 )
            CALL zswap( kp-k-1, a( k+1, k ), 1, a( kp, k+1 ), lda )
            temp = a( k, k )
            a( k, k ) = a( kp, kp )
            a( kp, kp ) = temp
            IF( kstep.EQ.2 ) THEN
               temp = a( k, k-1 )
               a( k, k-1 ) = a( kp, k-1 )
               a( kp, k-1 ) = temp
            END IF
         END IF
*
         k = k - kstep
         GO TO 50
   60    CONTINUE
      END IF
*
      RETURN
*
*     End of ZSYTRI
*

Here is the call graph for this function:

Here is the caller graph for this function: