csytri_rook()

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

CSYTRI_ROOK

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

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

[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_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.
[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_ROOK.
[out]	WORK	WORK is COMPLEX 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.

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

Definition at line 128 of file csytri_rook.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            CONE, CZERO
      parameter( cone = ( 1.0e+0, 0.0e+0 ),
     $                   czero = ( 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          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_ROOK', -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.czero )
     $         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.czero )
     $         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 ) = cone / 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, -cone, a, lda, work, 1, czero,
     $                     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-cone )
            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, -cone, a, lda, work, 1, czero,
     $                     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, -cone, a, lda, work, 1, czero,
     $                     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
*
         IF( kstep.EQ.1 ) THEN
*
*           Interchange rows and columns K and IPIV(K) in the leading
*           submatrix A(1:k+1,1:k+1)
*
            kp = ipiv( k )
            IF( kp.NE.k ) THEN
               IF( kp.GT.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
            END IF
         ELSE
*
*           Interchange rows and columns K and K+1 with -IPIV(K) and
*           -IPIV(K+1)in the leading submatrix A(1:k+1,1:k+1)
*
            kp = -ipiv( k )
            IF( kp.NE.k ) THEN
               IF( kp.GT.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
               temp = a( k, k+1 )
               a( k, k+1 ) = a( kp, k+1 )
               a( kp, k+1 ) = temp
            END IF
*
            k = k + 1
            kp = -ipiv( k )
            IF( kp.NE.k ) THEN
               IF( kp.GT.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
            END IF
         END IF
*
         k = k + 1
         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 ) = cone / 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,-cone, a( k+1, k+1 ), lda, work, 1,
     $                     czero, 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-cone )
            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,-cone, a( k+1, k+1 ), lda, work, 1,
     $                     czero, 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,-cone, a( k+1, k+1 ), lda, work, 1,
     $                     czero, 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
*
         IF( kstep.EQ.1 ) THEN
*
*           Interchange rows and columns K and IPIV(K) in the trailing
*           submatrix A(k-1:n,k-1:n)
*
            kp = ipiv( k )
            IF( kp.NE.k ) THEN
               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
            END IF
         ELSE
*
*           Interchange rows and columns K and K-1 with -IPIV(K) and
*           -IPIV(K-1) in the trailing submatrix A(k-1:n,k-1:n)
*
            kp = -ipiv( k )
            IF( kp.NE.k ) THEN
               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
               temp = a( k, k-1 )
               a( k, k-1 ) = a( kp, k-1 )
               a( kp, k-1 ) = temp
            END IF
*
            k = k - 1
            kp = -ipiv( k )
            IF( kp.NE.k ) THEN
               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
            END IF
         END IF
*
         k = k - 1
         GO TO 50
   60    CONTINUE
      END IF
*
      RETURN
*
*     End of CSYTRI_ROOK
*

Here is the call graph for this function:

Here is the caller graph for this function: