chetrs_rook()

subroutine chetrs_rook	(	character	uplo,
		integer	n,
		integer	nrhs,
		complex, dimension( lda, * )	a,
		integer	lda,
		integer, dimension( * )	ipiv,
		complex, dimension( ldb, * )	b,
		integer	ldb,
		integer	info
	)

CHETRS_ROOK computes the solution to a system of linear equations A * X = B for HE matrices using factorization obtained with one of the bounded diagonal pivoting methods (max 2 interchanges)

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

Purpose:

 CHETRS_ROOK solves a system of linear equations A*X = B with a complex
 Hermitian matrix A using the factorization A = U*D*U**H or
 A = L*D*L**H computed by CHETRF_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**H; = 'L': Lower triangular, form is A = L*D*L**H.
[in]	N	N is INTEGER The order of the matrix A. N >= 0.
[in]	NRHS	NRHS is INTEGER The number of right hand sides, i.e., the number of columns of the matrix B. NRHS >= 0.
[in]	A	A is COMPLEX array, dimension (LDA,N) The block diagonal matrix D and the multipliers used to obtain the factor U or L as computed by CHETRF_ROOK.
[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 CHETRF_ROOK.
[in,out]	B	B is COMPLEX array, dimension (LDB,NRHS) On entry, the right hand side matrix B. On exit, the solution matrix X.
[in]	LDB	LDB is INTEGER The leading dimension of the array B. LDB >= max(1,N).
[out]	INFO	INFO is INTEGER = 0: successful exit < 0: if INFO = -i, the i-th argument had an illegal value

Author

Univ. of Tennessee

Univ. of California Berkeley

Univ. of Colorado Denver

NAG Ltd.

Contributors:

  November 2013,  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 134 of file chetrs_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, LDB, N, NRHS
*     ..
*     .. Array Arguments ..
      INTEGER            IPIV( * )
      COMPLEX            A( LDA, * ), B( LDB, * )
*     ..
*
*  =====================================================================
*
*     .. Parameters ..
      COMPLEX            ONE
      parameter( one = ( 1.0e+0, 0.0e+0 ) )
*     ..
*     .. Local Scalars ..
      LOGICAL            UPPER
      INTEGER            J, K, KP
      REAL               S
      COMPLEX            AK, AKM1, AKM1K, BK, BKM1, DENOM
*     ..
*     .. External Functions ..
      LOGICAL            LSAME
      EXTERNAL           lsame
*     ..
*     .. External Subroutines ..
      EXTERNAL           cgemv, cgeru, clacgv, csscal, cswap, xerbla
*     ..
*     .. Intrinsic Functions ..
      INTRINSIC          conjg, max, real
*     ..
*     .. Executable Statements ..
*
      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( nrhs.LT.0 ) THEN
         info = -3
      ELSE IF( lda.LT.max( 1, n ) ) THEN
         info = -5
      ELSE IF( ldb.LT.max( 1, n ) ) THEN
         info = -8
      END IF
      IF( info.NE.0 ) THEN
         CALL xerbla( 'CHETRS_ROOK', -info )
         RETURN
      END IF
*
*     Quick return if possible
*
      IF( n.EQ.0 .OR. nrhs.EQ.0 )
     $   RETURN
*
      IF( upper ) THEN
*
*        Solve A*X = B, where A = U*D*U**H.
*
*        First solve U*D*X = B, overwriting B with X.
*
*        K is the main loop index, decreasing from N to 1 in steps of
*        1 or 2, depending on the size of the diagonal blocks.
*
         k = n
   10    CONTINUE
*
*        If K < 1, exit from loop.
*
         IF( k.LT.1 )
     $      GO TO 30
*
         IF( ipiv( k ).GT.0 ) THEN
*
*           1 x 1 diagonal block
*
*           Interchange rows K and IPIV(K).
*
            kp = ipiv( k )
            IF( kp.NE.k )
     $         CALL cswap( nrhs, b( k, 1 ), ldb, b( kp, 1 ), ldb )
*
*           Multiply by inv(U(K)), where U(K) is the transformation
*           stored in column K of A.
*
            CALL cgeru( k-1, nrhs, -one, a( 1, k ), 1, b( k, 1 ), ldb,
     $                  b( 1, 1 ), ldb )
*
*           Multiply by the inverse of the diagonal block.
*
            s = real( one ) / real( a( k, k ) )
            CALL csscal( nrhs, s, b( k, 1 ), ldb )
            k = k - 1
         ELSE
*
*           2 x 2 diagonal block
*
*           Interchange rows K and -IPIV(K), then K-1 and -IPIV(K-1)
*
            kp = -ipiv( k )
            IF( kp.NE.k )
     $         CALL cswap( nrhs, b( k, 1 ), ldb, b( kp, 1 ), ldb )
*
            kp = -ipiv( k-1)
            IF( kp.NE.k-1 )
     $         CALL cswap( nrhs, b( k-1, 1 ), ldb, b( kp, 1 ), ldb )
*
*           Multiply by inv(U(K)), where U(K) is the transformation
*           stored in columns K-1 and K of A.
*
            CALL cgeru( k-2, nrhs, -one, a( 1, k ), 1, b( k, 1 ), ldb,
     $                  b( 1, 1 ), ldb )
            CALL cgeru( k-2, nrhs, -one, a( 1, k-1 ), 1, b( k-1, 1 ),
     $                  ldb, b( 1, 1 ), ldb )
*
*           Multiply by the inverse of the diagonal block.
*
            akm1k = a( k-1, k )
            akm1 = a( k-1, k-1 ) / akm1k
            ak = a( k, k ) / conjg( akm1k )
            denom = akm1*ak - one
            DO 20 j = 1, nrhs
               bkm1 = b( k-1, j ) / akm1k
               bk = b( k, j ) / conjg( akm1k )
               b( k-1, j ) = ( ak*bkm1-bk ) / denom
               b( k, j ) = ( akm1*bk-bkm1 ) / denom
   20       CONTINUE
            k = k - 2
         END IF
*
         GO TO 10
   30    CONTINUE
*
*        Next solve U**H *X = B, overwriting B with X.
*
*        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
   40    CONTINUE
*
*        If K > N, exit from loop.
*
         IF( k.GT.n )
     $      GO TO 50
*
         IF( ipiv( k ).GT.0 ) THEN
*
*           1 x 1 diagonal block
*
*           Multiply by inv(U**H(K)), where U(K) is the transformation
*           stored in column K of A.
*
            IF( k.GT.1 ) THEN
               CALL clacgv( nrhs, b( k, 1 ), ldb )
               CALL cgemv( 'Conjugate transpose', k-1, nrhs, -one, b,
     $                     ldb, a( 1, k ), 1, one, b( k, 1 ), ldb )
               CALL clacgv( nrhs, b( k, 1 ), ldb )
            END IF
*
*           Interchange rows K and IPIV(K).
*
            kp = ipiv( k )
            IF( kp.NE.k )
     $         CALL cswap( nrhs, b( k, 1 ), ldb, b( kp, 1 ), ldb )
            k = k + 1
         ELSE
*
*           2 x 2 diagonal block
*
*           Multiply by inv(U**H(K+1)), where U(K+1) is the transformation
*           stored in columns K and K+1 of A.
*
            IF( k.GT.1 ) THEN
               CALL clacgv( nrhs, b( k, 1 ), ldb )
               CALL cgemv( 'Conjugate transpose', k-1, nrhs, -one, b,
     $                     ldb, a( 1, k ), 1, one, b( k, 1 ), ldb )
               CALL clacgv( nrhs, b( k, 1 ), ldb )
*
               CALL clacgv( nrhs, b( k+1, 1 ), ldb )
               CALL cgemv( 'Conjugate transpose', k-1, nrhs, -one, b,
     $                     ldb, a( 1, k+1 ), 1, one, b( k+1, 1 ), ldb )
               CALL clacgv( nrhs, b( k+1, 1 ), ldb )
            END IF
*
*           Interchange rows K and -IPIV(K), then K+1 and -IPIV(K+1)
*
            kp = -ipiv( k )
            IF( kp.NE.k )
     $         CALL cswap( nrhs, b( k, 1 ), ldb, b( kp, 1 ), ldb )
*
            kp = -ipiv( k+1 )
            IF( kp.NE.k+1 )
     $         CALL cswap( nrhs, b( k+1, 1 ), ldb, b( kp, 1 ), ldb )
*
            k = k + 2
         END IF
*
         GO TO 40
   50    CONTINUE
*
      ELSE
*
*        Solve A*X = B, where A = L*D*L**H.
*
*        First solve L*D*X = B, overwriting B with X.
*
*        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
   60    CONTINUE
*
*        If K > N, exit from loop.
*
         IF( k.GT.n )
     $      GO TO 80
*
         IF( ipiv( k ).GT.0 ) THEN
*
*           1 x 1 diagonal block
*
*           Interchange rows K and IPIV(K).
*
            kp = ipiv( k )
            IF( kp.NE.k )
     $         CALL cswap( nrhs, b( k, 1 ), ldb, b( kp, 1 ), ldb )
*
*           Multiply by inv(L(K)), where L(K) is the transformation
*           stored in column K of A.
*
            IF( k.LT.n )
     $         CALL cgeru( n-k, nrhs, -one, a( k+1, k ), 1, b( k, 1 ),
     $                     ldb, b( k+1, 1 ), ldb )
*
*           Multiply by the inverse of the diagonal block.
*
            s = real( one ) / real( a( k, k ) )
            CALL csscal( nrhs, s, b( k, 1 ), ldb )
            k = k + 1
         ELSE
*
*           2 x 2 diagonal block
*
*           Interchange rows K and -IPIV(K), then K+1 and -IPIV(K+1)
*
            kp = -ipiv( k )
            IF( kp.NE.k )
     $         CALL cswap( nrhs, b( k, 1 ), ldb, b( kp, 1 ), ldb )
*
            kp = -ipiv( k+1 )
            IF( kp.NE.k+1 )
     $         CALL cswap( nrhs, b( k+1, 1 ), ldb, b( kp, 1 ), ldb )
*
*           Multiply by inv(L(K)), where L(K) is the transformation
*           stored in columns K and K+1 of A.
*
            IF( k.LT.n-1 ) THEN
               CALL cgeru( n-k-1, nrhs, -one, a( k+2, k ), 1, b( k, 1 ),
     $                     ldb, b( k+2, 1 ), ldb )
               CALL cgeru( n-k-1, nrhs, -one, a( k+2, k+1 ), 1,
     $                     b( k+1, 1 ), ldb, b( k+2, 1 ), ldb )
            END IF
*
*           Multiply by the inverse of the diagonal block.
*
            akm1k = a( k+1, k )
            akm1 = a( k, k ) / conjg( akm1k )
            ak = a( k+1, k+1 ) / akm1k
            denom = akm1*ak - one
            DO 70 j = 1, nrhs
               bkm1 = b( k, j ) / conjg( akm1k )
               bk = b( k+1, j ) / akm1k
               b( k, j ) = ( ak*bkm1-bk ) / denom
               b( k+1, j ) = ( akm1*bk-bkm1 ) / denom
   70       CONTINUE
            k = k + 2
         END IF
*
         GO TO 60
   80    CONTINUE
*
*        Next solve L**H *X = B, overwriting B with X.
*
*        K is the main loop index, decreasing from N to 1 in steps of
*        1 or 2, depending on the size of the diagonal blocks.
*
         k = n
   90    CONTINUE
*
*        If K < 1, exit from loop.
*
         IF( k.LT.1 )
     $      GO TO 100
*
         IF( ipiv( k ).GT.0 ) THEN
*
*           1 x 1 diagonal block
*
*           Multiply by inv(L**H(K)), where L(K) is the transformation
*           stored in column K of A.
*
            IF( k.LT.n ) THEN
               CALL clacgv( nrhs, b( k, 1 ), ldb )
               CALL cgemv( 'Conjugate transpose', n-k, nrhs, -one,
     $                     b( k+1, 1 ), ldb, a( k+1, k ), 1, one,
     $                     b( k, 1 ), ldb )
               CALL clacgv( nrhs, b( k, 1 ), ldb )
            END IF
*
*           Interchange rows K and IPIV(K).
*
            kp = ipiv( k )
            IF( kp.NE.k )
     $         CALL cswap( nrhs, b( k, 1 ), ldb, b( kp, 1 ), ldb )
            k = k - 1
         ELSE
*
*           2 x 2 diagonal block
*
*           Multiply by inv(L**H(K-1)), where L(K-1) is the transformation
*           stored in columns K-1 and K of A.
*
            IF( k.LT.n ) THEN
               CALL clacgv( nrhs, b( k, 1 ), ldb )
               CALL cgemv( 'Conjugate transpose', n-k, nrhs, -one,
     $                     b( k+1, 1 ), ldb, a( k+1, k ), 1, one,
     $                     b( k, 1 ), ldb )
               CALL clacgv( nrhs, b( k, 1 ), ldb )
*
               CALL clacgv( nrhs, b( k-1, 1 ), ldb )
               CALL cgemv( 'Conjugate transpose', n-k, nrhs, -one,
     $                     b( k+1, 1 ), ldb, a( k+1, k-1 ), 1, one,
     $                     b( k-1, 1 ), ldb )
               CALL clacgv( nrhs, b( k-1, 1 ), ldb )
            END IF
*
*           Interchange rows K and -IPIV(K), then K-1 and -IPIV(K-1)
*
            kp = -ipiv( k )
            IF( kp.NE.k )
     $         CALL cswap( nrhs, b( k, 1 ), ldb, b( kp, 1 ), ldb )
*
            kp = -ipiv( k-1 )
            IF( kp.NE.k-1 )
     $         CALL cswap( nrhs, b( k-1, 1 ), ldb, b( kp, 1 ), ldb )
*
            k = k - 2
         END IF
*
         GO TO 90
  100    CONTINUE
      END IF
*
      RETURN
*
*     End of CHETRS_ROOK
*

Here is the call graph for this function:

Here is the caller graph for this function: