ztrexc()

subroutine ztrexc	(	character	compq,
		integer	n,
		complex*16, dimension( ldt, * )	t,
		integer	ldt,
		complex*16, dimension( ldq, * )	q,
		integer	ldq,
		integer	ifst,
		integer	ilst,
		integer	info )

ZTREXC

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

Purpose:

!>
!> ZTREXC reorders the Schur factorization of a complex matrix
!> A = Q*T*Q**H, so that the diagonal element of T with row index IFST
!> is moved to row ILST.
!>
!> The Schur form T is reordered by a unitary similarity transformation
!> Z**H*T*Z, and optionally the matrix Q of Schur vectors is updated by
!> postmultiplying it with Z.
!> 

Parameters

[in]	COMPQ	!> COMPQ is CHARACTER*1 !> = 'V': update the matrix Q of Schur vectors; !> = 'N': do not update Q. !>
[in]	N	!> N is INTEGER !> The order of the matrix T. N >= 0. !> If N == 0 arguments ILST and IFST may be any value. !>
[in,out]	T	!> T is COMPLEX*16 array, dimension (LDT,N) !> On entry, the upper triangular matrix T. !> On exit, the reordered upper triangular matrix. !>
[in]	LDT	!> LDT is INTEGER !> The leading dimension of the array T. LDT >= max(1,N). !>
[in,out]	Q	!> Q is COMPLEX*16 array, dimension (LDQ,N) !> On entry, if COMPQ = 'V', the matrix Q of Schur vectors. !> On exit, if COMPQ = 'V', Q has been postmultiplied by the !> unitary transformation matrix Z which reorders T. !> If COMPQ = 'N', Q is not referenced. !>
[in]	LDQ	!> LDQ is INTEGER !> The leading dimension of the array Q. LDQ >= 1, and if !> COMPQ = 'V', LDQ >= max(1,N). !>
[in]	IFST	!> IFST is INTEGER !>
[in]	ILST	!> ILST is INTEGER !> !> Specify the reordering of the diagonal elements of T: !> The element with row index IFST is moved to row ILST by a !> sequence of transpositions between adjacent elements. !> 1 <= IFST <= N; 1 <= ILST <= 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.

Definition at line 123 of file ztrexc.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          COMPQ
      INTEGER            IFST, ILST, INFO, LDQ, LDT, N
*     ..
*     .. Array Arguments ..
      COMPLEX*16         Q( LDQ, * ), T( LDT, * )
*     ..
*
*  =====================================================================
*
*     .. Local Scalars ..
      LOGICAL            WANTQ
      INTEGER            K, M1, M2, M3
      DOUBLE PRECISION   CS
      COMPLEX*16         SN, T11, T22, TEMP
*     ..
*     .. External Functions ..
      LOGICAL            LSAME
      EXTERNAL           lsame
*     ..
*     .. External Subroutines ..
      EXTERNAL           xerbla, zlartg, zrot
*     ..
*     .. Intrinsic Functions ..
      INTRINSIC          dconjg, max
*     ..
*     .. Executable Statements ..
*
*     Decode and test the input parameters.
*
      info = 0
      wantq = lsame( compq, 'V' )
      IF( .NOT.lsame( compq, 'N' ) .AND. .NOT.wantq ) THEN
         info = -1
      ELSE IF( n.LT.0 ) THEN
         info = -2
      ELSE IF( ldt.LT.max( 1, n ) ) THEN
         info = -4
      ELSE IF( ldq.LT.1 .OR. ( wantq .AND. ldq.LT.max( 1, n ) ) ) THEN
         info = -6
      ELSE IF(( ifst.LT.1 .OR. ifst.GT.n ).AND.( n.GT.0 )) THEN
         info = -7
      ELSE IF(( ilst.LT.1 .OR. ilst.GT.n ).AND.( n.GT.0 )) THEN
         info = -8
      END IF
      IF( info.NE.0 ) THEN
         CALL xerbla( 'ZTREXC', -info )
         RETURN
      END IF
*
*     Quick return if possible
*
      IF( n.LE.1 .OR. ifst.EQ.ilst )
     $   RETURN
*
      IF( ifst.LT.ilst ) THEN
*
*        Move the IFST-th diagonal element forward down the diagonal.
*
         m1 = 0
         m2 = -1
         m3 = 1
      ELSE
*
*        Move the IFST-th diagonal element backward up the diagonal.
*
         m1 = -1
         m2 = 0
         m3 = -1
      END IF
*
      DO 10 k = ifst + m1, ilst + m2, m3
*
*        Interchange the k-th and (k+1)-th diagonal elements.
*
         t11 = t( k, k )
         t22 = t( k+1, k+1 )
*
*        Determine the transformation to perform the interchange.
*
         CALL zlartg( t( k, k+1 ), t22-t11, cs, sn, temp )
*
*        Apply transformation to the matrix T.
*
         IF( k+2.LE.n )
     $      CALL zrot( n-k-1, t( k, k+2 ), ldt, t( k+1, k+2 ), ldt,
     $                 cs,
     $                 sn )
         CALL zrot( k-1, t( 1, k ), 1, t( 1, k+1 ), 1, cs,
     $              dconjg( sn ) )
*
         t( k, k ) = t22
         t( k+1, k+1 ) = t11
*
         IF( wantq ) THEN
*
*           Accumulate transformation in the matrix Q.
*
            CALL zrot( n, q( 1, k ), 1, q( 1, k+1 ), 1, cs,
     $                 dconjg( sn ) )
         END IF
*
   10 CONTINUE
*
      RETURN
*
*     End of ZTREXC
*

Here is the call graph for this function:

Here is the caller graph for this function: