zlaqz1()

subroutine zlaqz1	(	logical, intent(in)	ilq,
		logical, intent(in)	ilz,
		integer, intent(in)	k,
		integer, intent(in)	istartm,
		integer, intent(in)	istopm,
		integer, intent(in)	ihi,
		complex*16, dimension( lda, * )	a,
		integer, intent(in)	lda,
		complex*16, dimension( ldb, * )	b,
		integer, intent(in)	ldb,
		integer, intent(in)	nq,
		integer, intent(in)	qstart,
		complex*16, dimension( ldq, * )	q,
		integer, intent(in)	ldq,
		integer, intent(in)	nz,
		integer, intent(in)	zstart,
		complex*16, dimension( ldz, * )	z,
		integer, intent(in)	ldz )

ZLAQZ1

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

Purpose:

!>
!>      ZLAQZ1 chases a 1x1 shift bulge in a matrix pencil down a single position
!> 

Parameters

[in]	ILQ	!> ILQ is LOGICAL !> Determines whether or not to update the matrix Q !>
[in]	ILZ	!> ILZ is LOGICAL !> Determines whether or not to update the matrix Z !>
[in]	K	!> K is INTEGER !> Index indicating the position of the bulge. !> On entry, the bulge is located in !> (A(k+1,k),B(k+1,k)). !> On exit, the bulge is located in !> (A(k+2,k+1),B(k+2,k+1)). !>
[in]	ISTARTM	!> ISTARTM is INTEGER !>
[in]	ISTOPM	!> ISTOPM is INTEGER !> Updates to (A,B) are restricted to !> (istartm:k+2,k:istopm). It is assumed !> without checking that istartm <= k+1 and !> k+2 <= istopm !>
[in]	IHI	!> IHI is INTEGER !>
[in,out]	A	!> A is COMPLEX*16 array, dimension (LDA,N) !>
[in]	LDA	!> LDA is INTEGER !> The leading dimension of A as declared in !> the calling procedure. !>
[in,out]	B	!> B is COMPLEX*16 array, dimension (LDB,N) !>
[in]	LDB	!> LDB is INTEGER !> The leading dimension of B as declared in !> the calling procedure. !>
[in]	NQ	!> NQ is INTEGER !> The order of the matrix Q !>
[in]	QSTART	!> QSTART is INTEGER !> Start index of the matrix Q. Rotations are applied !> To columns k+2-qStart:k+3-qStart of Q. !>
[in,out]	Q	!> Q is COMPLEX*16 array, dimension (LDQ,NQ) !>
[in]	LDQ	!> LDQ is INTEGER !> The leading dimension of Q as declared in !> the calling procedure. !>
[in]	NZ	!> NZ is INTEGER !> The order of the matrix Z !>
[in]	ZSTART	!> ZSTART is INTEGER !> Start index of the matrix Z. Rotations are applied !> To columns k+1-qStart:k+2-qStart of Z. !>
[in,out]	Z	!> Z is COMPLEX*16 array, dimension (LDZ,NZ) !>
[in]	LDZ	!> LDZ is INTEGER !> The leading dimension of Q as declared in !> the calling procedure. !>

Author

Thijs Steel, KU Leuven

Date

May 2020

Definition at line 169 of file zlaqz1.f.

      IMPLICIT NONE
*
*     Arguments
      LOGICAL, INTENT( IN ) :: ILQ, ILZ
      INTEGER, INTENT( IN ) :: K, LDA, LDB, LDQ, LDZ, ISTARTM, ISTOPM,
     $         NQ, NZ, QSTART, ZSTART, IHI
      COMPLEX*16 :: A( LDA, * ), B( LDB, * ), Q( LDQ, * ), Z( LDZ, * )
*
*     Parameters
      COMPLEX*16         CZERO, CONE
      parameter( czero = ( 0.0d+0, 0.0d+0 ), cone = ( 1.0d+0,
     $                     0.0d+0 ) )
      DOUBLE PRECISION :: ZERO, ONE, HALF
      parameter( zero = 0.0d0, one = 1.0d0, half = 0.5d0 )
*
*     Local variables
      DOUBLE PRECISION :: C
      COMPLEX*16 :: S, TEMP
*
*     External Functions
      EXTERNAL :: zlartg, zrot
*
      IF( k+1 .EQ. ihi ) THEN
*
*        Shift is located on the edge of the matrix, remove it
*
         CALL zlartg( b( ihi, ihi ), b( ihi, ihi-1 ), c, s, temp )
         b( ihi, ihi ) = temp
         b( ihi, ihi-1 ) = czero
         CALL zrot( ihi-istartm, b( istartm, ihi ), 1, b( istartm,
     $              ihi-1 ), 1, c, s )
         CALL zrot( ihi-istartm+1, a( istartm, ihi ), 1, a( istartm,
     $              ihi-1 ), 1, c, s )
         IF ( ilz ) THEN
            CALL zrot( nz, z( 1, ihi-zstart+1 ), 1, z( 1,
     $                 ihi-1-zstart+
     $                 1 ), 1, c, s )
         END IF
*
      ELSE
*
*        Normal operation, move bulge down
*
*
*        Apply transformation from the right
*
         CALL zlartg( b( k+1, k+1 ), b( k+1, k ), c, s, temp )
         b( k+1, k+1 ) = temp
         b( k+1, k ) = czero
         CALL zrot( k+2-istartm+1, a( istartm, k+1 ), 1, a( istartm,
     $              k ), 1, c, s )
         CALL zrot( k-istartm+1, b( istartm, k+1 ), 1, b( istartm,
     $              k ),
     $              1, c, s )
         IF ( ilz ) THEN
            CALL zrot( nz, z( 1, k+1-zstart+1 ), 1, z( 1,
     $                 k-zstart+1 ),
     $                 1, c, s )
         END IF
*
*        Apply transformation from the left
*
         CALL zlartg( a( k+1, k ), a( k+2, k ), c, s, temp )
         a( k+1, k ) = temp
         a( k+2, k ) = czero
         CALL zrot( istopm-k, a( k+1, k+1 ), lda, a( k+2, k+1 ), lda,
     $              c,
     $              s )
         CALL zrot( istopm-k, b( k+1, k+1 ), ldb, b( k+2, k+1 ), ldb,
     $              c,
     $              s )
         IF ( ilq ) THEN
            CALL zrot( nq, q( 1, k+1-qstart+1 ), 1, q( 1, k+2-qstart+
     $                 1 ), 1, c, dconjg( s ) )
         END IF
*
      END IF
*
*     End of ZLAQZ1
*

Here is the call graph for this function:

Here is the caller graph for this function: