csptri()

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

CSPTRI

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

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

[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 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.
[in]	IPIV	IPIV is INTEGER array, dimension (N) Details of the interchanges and the block structure of D as determined by CSPTRF.
[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.

Definition at line 108 of file csptri.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            AP( * ), 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            J, K, KC, KCNEXT, KP, KPC, KSTEP, KX, NPP
      COMPLEX            AK, AKKP1, AKP1, D, T, TEMP
*     ..
*     .. External Functions ..
      LOGICAL            LSAME
      COMPLEX            CDOTU
      EXTERNAL           lsame, cdotu
*     ..
*     .. External Subroutines ..
      EXTERNAL           ccopy, cspmv, cswap, xerbla
*     ..
*     .. 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( 'CSPTRI', -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 ccopy( k-1, ap( kc ), 1, work, 1 )
               CALL cspmv( uplo, k-1, -one, ap, work, 1, zero, ap( kc ),
     $                     1 )
               ap( kc+k-1 ) = ap( kc+k-1 ) -
     $                        cdotu( 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 ccopy( k-1, ap( kc ), 1, work, 1 )
               CALL cspmv( uplo, k-1, -one, ap, work, 1, zero, ap( kc ),
     $                     1 )
               ap( kc+k-1 ) = ap( kc+k-1 ) -
     $                        cdotu( k-1, work, 1, ap( kc ), 1 )
               ap( kcnext+k-1 ) = ap( kcnext+k-1 ) -
     $                            cdotu( k-1, ap( kc ), 1, ap( kcnext ),
     $                            1 )
               CALL ccopy( k-1, ap( kcnext ), 1, work, 1 )
               CALL cspmv( uplo, k-1, -one, ap, work, 1, zero,
     $                     ap( kcnext ), 1 )
               ap( kcnext+k ) = ap( kcnext+k ) -
     $                          cdotu( 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 cswap( 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 ccopy( n-k, ap( kc+1 ), 1, work, 1 )
               CALL cspmv( uplo, n-k, -one, ap( kc+n-k+1 ), work, 1,
     $                     zero, ap( kc+1 ), 1 )
               ap( kc ) = ap( kc ) - cdotu( 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 ccopy( n-k, ap( kc+1 ), 1, work, 1 )
               CALL cspmv( uplo, n-k, -one, ap( kc+( n-k+1 ) ), work, 1,
     $                     zero, ap( kc+1 ), 1 )
               ap( kc ) = ap( kc ) - cdotu( n-k, work, 1, ap( kc+1 ),
     $                    1 )
               ap( kcnext+1 ) = ap( kcnext+1 ) -
     $                          cdotu( n-k, ap( kc+1 ), 1,
     $                          ap( kcnext+2 ), 1 )
               CALL ccopy( n-k, ap( kcnext+2 ), 1, work, 1 )
               CALL cspmv( uplo, n-k, -one, ap( kc+( n-k+1 ) ), work, 1,
     $                     zero, ap( kcnext+2 ), 1 )
               ap( kcnext ) = ap( kcnext ) -
     $                        cdotu( 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 cswap( 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 CSPTRI
*

Here is the call graph for this function:

Here is the caller graph for this function: