stgsy2()

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

STGSY2 solves the generalized Sylvester equation (unblocked algorithm).

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

Purpose:

!>
!> STGSY2 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, with real entries. (A, D) and (B, E)
!> must be in generalized Schur canonical form, i.e. A, B are upper
!> quasi triangular and D, E are upper triangular. 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
!> Z*x = scale*b, where Z is defined as
!>
!>        Z = [ kron(In, A)  -kron(B**T, Im) ]             (2)
!>            [ kron(In, D)  -kron(E**T, Im) ],
!>
!> Ik is the identity matrix of size k and X**T is the transpose of X.
!> kron(X, Y) is the Kronecker product between the matrices X and Y.
!> In the process of solving (1), we solve a number of such systems
!> where Dim(In), Dim(In) = 1 or 2.
!>
!> If TRANS = 'T', solve the transposed system Z**T*y = scale*b for y,
!> which is equivalent to solve for R and L in
!>
!>             A**T * R  + D**T * L   = scale * C           (3)
!>             R  * B**T + L  * E**T  = scale * -F
!>
!> This case is used to compute an estimate of Dif[(A, D), (B, E)] =
!> sigma_min(Z) using reverse communication with SLACON.
!>
!> STGSY2 also (IJOB >= 1) contributes to the computation in STGSYL
!> of an upper bound on the separation between to matrix pairs. Then
!> the input (A, D), (B, E) are sub-pencils of the matrix pair in
!> STGSYL. See STGSYL for details.
!> 

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 REAL array, dimension (LDA, M) !> On entry, A contains an upper quasi triangular matrix. !>
[in]	LDA	!> LDA is INTEGER !> The leading dimension of the matrix A. LDA >= max(1, M). !>
[in]	B	!> B is REAL array, dimension (LDB, N) !> On entry, B contains an upper quasi triangular matrix. !>
[in]	LDB	!> LDB is INTEGER !> The leading dimension of the matrix B. LDB >= max(1, N). !>
[in,out]	C	!> C is REAL 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 REAL 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 REAL 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 REAL 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 STGSYL, 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 STGSY2 is called by STGSYL. !>
[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 STGSY2 is called by !> STGSYL. !>
[out]	IWORK	!> IWORK is INTEGER array, dimension (M+N+2) !>
[out]	PQ	!> PQ is INTEGER !> On exit, the number of subsystems (of size 2-by-2, 4-by-4 and !> 8-by-8) solved by this routine. !>
[out]	INFO	!> INFO is INTEGER !> On exit, if INFO is set to !> =0: Successful exit !> <0: If INFO = -i, the i-th argument had an illegal value. !> >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.