csytri()

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

CSYTRI

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

Purpose:

 CSYTRI 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
 CSYTRF.

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 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. 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 CSYTRF.
[out]	WORK	WORK is COMPLEX 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 csytri.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            A( LDA, * ), WORK( * )
*     ..
*
*  =====================================================================
*
*     .. Parameters ..
      COMPLEX            ONE, ZERO
      parameter( one = ( 1.0e+0, 0.0e+0 ),
     $                   zero = ( 0.0e+0, 0.0e+0 ) )
*     ..
*     .. Local Scalars ..
      LOGICAL            UPPER
      INTEGER            K, KP, KSTEP
      COMPLEX            AK, AKKP1, AKP1, D, T, TEMP
*     ..
*     .. External Functions ..
      LOGICAL            LSAME
      COMPLEX            CDOTU
      EXTERNAL           lsame, cdotu
*     ..
*     .. External Subroutines ..
      EXTERNAL           ccopy, cswap, csymv, xerbla
*     ..
*     .. 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( 'CSYTRI', -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 ccopy( k-1, a( 1, k ), 1, work, 1 )
               CALL csymv( uplo, k-1, -one, a, lda, work, 1, zero,
     $                     a( 1, k ), 1 )
               a( k, k ) = a( k, k ) - cdotu( 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 ccopy( k-1, a( 1, k ), 1, work, 1 )
               CALL csymv( uplo, k-1, -one, a, lda, work, 1, zero,
     $                     a( 1, k ), 1 )
               a( k, k ) = a( k, k ) - cdotu( k-1, work, 1, a( 1, k ),
     $                     1 )
               a( k, k+1 ) = a( k, k+1 ) -
     $                       cdotu( k-1, a( 1, k ), 1, a( 1, k+1 ), 1 )
               CALL ccopy( k-1, a( 1, k+1 ), 1, work, 1 )
               CALL csymv( uplo, k-1, -one, a, lda, work, 1, zero,
     $                     a( 1, k+1 ), 1 )
               a( k+1, k+1 ) = a( k+1, k+1 ) -
     $                         cdotu( 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 cswap( kp-1, a( 1, k ), 1, a( 1, kp ), 1 )
            CALL cswap( 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 ccopy( n-k, a( k+1, k ), 1, work, 1 )
               CALL csymv( uplo, n-k, -one, a( k+1, k+1 ), lda, work, 1,
     $                     zero, a( k+1, k ), 1 )
               a( k, k ) = a( k, k ) - cdotu( 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 ccopy( n-k, a( k+1, k ), 1, work, 1 )
               CALL csymv( uplo, n-k, -one, a( k+1, k+1 ), lda, work, 1,
     $                     zero, a( k+1, k ), 1 )
               a( k, k ) = a( k, k ) - cdotu( n-k, work, 1, a( k+1, k ),
     $                     1 )
               a( k, k-1 ) = a( k, k-1 ) -
     $                       cdotu( n-k, a( k+1, k ), 1, a( k+1, k-1 ),
     $                       1 )
               CALL ccopy( n-k, a( k+1, k-1 ), 1, work, 1 )
               CALL csymv( 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 ) -
     $                         cdotu( 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 cswap( n-kp, a( kp+1, k ), 1, a( kp+1, kp ), 1 )
            CALL cswap( 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 CSYTRI
*

Here is the call graph for this function:

Here is the caller graph for this function: