ctgsy2()

subroutine ctgsy2	(	character	trans,
		integer	ijob,
		integer	m,
		integer	n,
		complex, dimension( lda, * )	a,
		integer	lda,
		complex, dimension( ldb, * )	b,
		integer	ldb,
		complex, dimension( ldc, * )	c,
		integer	ldc,
		complex, dimension( ldd, * )	d,
		integer	ldd,
		complex, dimension( lde, * )	e,
		integer	lde,
		complex, dimension( ldf, * )	f,
		integer	ldf,
		real	scale,
		real	rdsum,
		real	rdscal,
		integer	info )

CTGSY2 solves the generalized Sylvester equation (unblocked algorithm).

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

Purpose:

!>
!> CTGSY2 solves the generalized Sylvester equation
!>
!>             A * R - L * B = scale *  C               (1)
!>             D * R - L * E = scale * F
!>
!> using Level 1 and 2 BLAS, where R and L are unknown M-by-N matrices,
!> (A, D), (B, E) and (C, F) are given matrix pairs of size M-by-M,
!> N-by-N and M-by-N, respectively. A, B, D and E are upper triangular
!> (i.e., (A,D) and (B,E) in generalized Schur form).
!>
!> The solution (R, L) overwrites (C, F). 0 <= SCALE <= 1 is an output
!> scaling factor chosen to avoid overflow.
!>
!> In matrix notation solving equation (1) corresponds to solve
!> Zx = scale * b, where Z is defined as
!>
!>        Z = [ kron(In, A)  -kron(B**H, Im) ]             (2)
!>            [ kron(In, D)  -kron(E**H, Im) ],
!>
!> Ik is the identity matrix of size k and X**H is the transpose of X.
!> kron(X, Y) is the Kronecker product between the matrices X and Y.
!>
!> If TRANS = 'C', y in the conjugate transposed system Z**H*y = scale*b
!> is solved for, which is equivalent to solve for R and L in
!>
!>             A**H * R  + D**H * L   = scale * C           (3)
!>             R  * B**H + L  * E**H  = scale * -F
!>
!> This case is used to compute an estimate of Dif[(A, D), (B, E)] =
!> = sigma_min(Z) using reverse communication with CLACON.
!>
!> CTGSY2 also (IJOB >= 1) contributes to the computation in CTGSYL
!> of an upper bound on the separation between to matrix pairs. Then
!> the input (A, D), (B, E) are sub-pencils of two matrix pairs in
!> CTGSYL.
!> 

Parameters

[in]	TRANS	!> TRANS is CHARACTER*1 !> = 'N': solve the generalized Sylvester equation (1). !> = 'T': solve the 'transposed' system (3). !>
[in]	IJOB	!> IJOB is INTEGER !> Specifies what kind of functionality to be performed. !> = 0: solve (1) only. !> = 1: A contribution from this subsystem to a Frobenius !> norm-based estimate of the separation between two matrix !> pairs is computed. (look ahead strategy is used). !> = 2: A contribution from this subsystem to a Frobenius !> norm-based estimate of the separation between two matrix !> pairs is computed. (SGECON on sub-systems is used.) !> Not referenced if TRANS = 'T'. !>
[in]	M	!> M is INTEGER !> On entry, M specifies the order of A and D, and the row !> dimension of C, F, R and L. !>
[in]	N	!> N is INTEGER !> On entry, N specifies the order of B and E, and the column !> dimension of C, F, R and L. !>
[in]	A	!> A is COMPLEX array, dimension (LDA, M) !> On entry, A contains an upper triangular matrix. !>
[in]	LDA	!> LDA is INTEGER !> The leading dimension of the matrix A. LDA >= max(1, M). !>
[in]	B	!> B is COMPLEX array, dimension (LDB, N) !> On entry, B contains an upper triangular matrix. !>
[in]	LDB	!> LDB is INTEGER !> The leading dimension of the matrix B. LDB >= max(1, N). !>
[in,out]	C	!> C is COMPLEX array, dimension (LDC, N) !> On entry, C contains the right-hand-side of the first matrix !> equation in (1). !> On exit, if IJOB = 0, C has been overwritten by the solution !> R. !>
[in]	LDC	!> LDC is INTEGER !> The leading dimension of the matrix C. LDC >= max(1, M). !>
[in]	D	!> D is COMPLEX array, dimension (LDD, M) !> On entry, D contains an upper triangular matrix. !>
[in]	LDD	!> LDD is INTEGER !> The leading dimension of the matrix D. LDD >= max(1, M). !>
[in]	E	!> E is COMPLEX array, dimension (LDE, N) !> On entry, E contains an upper triangular matrix. !>
[in]	LDE	!> LDE is INTEGER !> The leading dimension of the matrix E. LDE >= max(1, N). !>
[in,out]	F	!> F is COMPLEX array, dimension (LDF, N) !> On entry, F contains the right-hand-side of the second matrix !> equation in (1). !> On exit, if IJOB = 0, F has been overwritten by the solution !> L. !>
[in]	LDF	!> LDF is INTEGER !> The leading dimension of the matrix F. LDF >= max(1, M). !>
[out]	SCALE	!> SCALE is REAL !> On exit, 0 <= SCALE <= 1. If 0 < SCALE < 1, the solutions !> R and L (C and F on entry) will hold the solutions to a !> slightly perturbed system but the input matrices A, B, D and !> E have not been changed. If SCALE = 0, R and L will hold the !> solutions to the homogeneous system with C = F = 0. !> Normally, SCALE = 1. !>
[in,out]	RDSUM	!> RDSUM is REAL !> On entry, the sum of squares of computed contributions to !> the Dif-estimate under computation by CTGSYL, where the !> scaling factor RDSCAL (see below) has been factored out. !> On exit, the corresponding sum of squares updated with the !> contributions from the current sub-system. !> If TRANS = 'T' RDSUM is not touched. !> NOTE: RDSUM only makes sense when CTGSY2 is called by !> CTGSYL. !>
[in,out]	RDSCAL	!> RDSCAL is REAL !> On entry, scaling factor used to prevent overflow in RDSUM. !> On exit, RDSCAL is updated w.r.t. the current contributions !> in RDSUM. !> If TRANS = 'T', RDSCAL is not touched. !> NOTE: RDSCAL only makes sense when CTGSY2 is called by !> CTGSYL. !>
[out]	INFO	!> INFO is INTEGER !> On exit, if INFO is set to !> =0: Successful exit !> <0: If INFO = -i, input argument number i is illegal. !> >0: The matrix pairs (A, D) and (B, E) have common or very !> close eigenvalues. !>

Author

Univ. of Tennessee

Univ. of California Berkeley

Univ. of Colorado Denver

NAG Ltd.

Contributors:

Bo Kagstrom and Peter Poromaa, Department of Computing Science, Umea University, S-901 87 Umea, Sweden.