 LAPACK 3.11.0 LAPACK: Linear Algebra PACKage
Searching...
No Matches

## ◆ ztgsyl()

 subroutine ztgsyl ( character TRANS, integer IJOB, integer M, integer N, complex*16, dimension( lda, * ) A, integer LDA, complex*16, dimension( ldb, * ) B, integer LDB, complex*16, dimension( ldc, * ) C, integer LDC, complex*16, dimension( ldd, * ) D, integer LDD, complex*16, dimension( lde, * ) E, integer LDE, complex*16, dimension( ldf, * ) F, integer LDF, double precision SCALE, double precision DIF, complex*16, dimension( * ) WORK, integer LWORK, integer, dimension( * ) IWORK, integer INFO )

ZTGSYL

Purpose:
``` ZTGSYL solves the generalized Sylvester equation:

A * R - L * B = scale * C            (1)
D * R - L * E = scale * F

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 complex entries. 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 (1) is equivalent 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) ],

Here Ix is the identity matrix of size x and X**H is the conjugate
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 (TRANS = 'C') is used to compute an one-norm-based estimate
of Dif[(A,D), (B,E)], the separation between the matrix pairs (A,D)
and (B,E), using ZLACON.

If IJOB >= 1, ZTGSYL computes a Frobenius norm-based estimate of
Dif[(A,D),(B,E)]. That is, the reciprocal of a lower bound on the
reciprocal of the smallest singular value of Z.

This is a level-3 BLAS algorithm.```
Parameters
 [in] TRANS ``` TRANS is CHARACTER*1 = 'N': solve the generalized sylvester equation (1). = 'C': solve the "conjugate transposed" system (3).``` [in] IJOB ``` IJOB is INTEGER Specifies what kind of functionality to be performed. =0: solve (1) only. =1: The functionality of 0 and 3. =2: The functionality of 0 and 4. =3: Only an estimate of Dif[(A,D), (B,E)] is computed. (look ahead strategy is used). =4: Only an estimate of Dif[(A,D), (B,E)] is computed. (ZGECON on sub-systems is used). Not referenced if TRANS = 'C'.``` [in] M ``` M is INTEGER The order of the matrices A and D, and the row dimension of the matrices C, F, R and L.``` [in] N ``` N is INTEGER The order of the matrices B and E, and the column dimension of the matrices C, F, R and L.``` [in] A ``` A is COMPLEX*16 array, dimension (LDA, M) The upper triangular matrix A.``` [in] LDA ``` LDA is INTEGER The leading dimension of the array A. LDA >= max(1, M).``` [in] B ``` B is COMPLEX*16 array, dimension (LDB, N) The upper triangular matrix B.``` [in] LDB ``` LDB is INTEGER The leading dimension of the array B. LDB >= max(1, N).``` [in,out] C ``` C is COMPLEX*16 array, dimension (LDC, N) On entry, C contains the right-hand-side of the first matrix equation in (1) or (3). On exit, if IJOB = 0, 1 or 2, C has been overwritten by the solution R. If IJOB = 3 or 4 and TRANS = 'N', C holds R, the solution achieved during the computation of the Dif-estimate.``` [in] LDC ``` LDC is INTEGER The leading dimension of the array C. LDC >= max(1, M).``` [in] D ``` D is COMPLEX*16 array, dimension (LDD, M) The upper triangular matrix D.``` [in] LDD ``` LDD is INTEGER The leading dimension of the array D. LDD >= max(1, M).``` [in] E ``` E is COMPLEX*16 array, dimension (LDE, N) The upper triangular matrix E.``` [in] LDE ``` LDE is INTEGER The leading dimension of the array E. LDE >= max(1, N).``` [in,out] F ``` F is COMPLEX*16 array, dimension (LDF, N) On entry, F contains the right-hand-side of the second matrix equation in (1) or (3). On exit, if IJOB = 0, 1 or 2, F has been overwritten by the solution L. If IJOB = 3 or 4 and TRANS = 'N', F holds L, the solution achieved during the computation of the Dif-estimate.``` [in] LDF ``` LDF is INTEGER The leading dimension of the array F. LDF >= max(1, M).``` [out] DIF ``` DIF is DOUBLE PRECISION On exit DIF is the reciprocal of a lower bound of the reciprocal of the Dif-function, i.e. DIF is an upper bound of Dif[(A,D), (B,E)] = sigma-min(Z), where Z as in (2). IF IJOB = 0 or TRANS = 'C', DIF is not referenced.``` [out] SCALE ``` SCALE is DOUBLE PRECISION On exit SCALE is the scaling factor in (1) or (3). If 0 < SCALE < 1, C and F hold the solutions R and L, resp., 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.``` [out] WORK ``` WORK is COMPLEX*16 array, dimension (MAX(1,LWORK)) On exit, if INFO = 0, WORK(1) returns the optimal LWORK.``` [in] LWORK ``` LWORK is INTEGER The dimension of the array WORK. LWORK > = 1. If IJOB = 1 or 2 and TRANS = 'N', LWORK >= max(1,2*M*N). If LWORK = -1, then a workspace query is assumed; the routine only calculates the optimal size of the WORK array, returns this value as the first entry of the WORK array, and no error message related to LWORK is issued by XERBLA.``` [out] IWORK ` IWORK is INTEGER array, dimension (M+N+2)` [out] INFO ``` INFO is INTEGER =0: successful exit <0: If INFO = -i, the i-th argument had an illegal value. >0: (A, D) and (B, E) have common or very close eigenvalues.```
Contributors:
Bo Kagstrom and Peter Poromaa, Department of Computing Science, Umea University, S-901 87 Umea, Sweden.
References:
 B. Kagstrom and P. Poromaa, LAPACK-Style Algorithms and Software for Solving the Generalized Sylvester Equation and Estimating the Separation between Regular Matrix Pairs, Report UMINF - 93.23, Department of Computing Science, Umea University, S-901 87 Umea, Sweden, December 1993, Revised April 1994, Also as LAPACK Working Note 75. To appear in ACM Trans. on Math. Software, Vol 22, No 1, 1996.
 B. Kagstrom, A Perturbation Analysis of the Generalized Sylvester Equation (AR - LB, DR - LE ) = (C, F), SIAM J. Matrix Anal. Appl., 15(4):1045-1060, 1994.
 B. Kagstrom and L. Westin, Generalized Schur Methods with Condition Estimators for Solving the Generalized Sylvester Equation, IEEE Transactions on Automatic Control, Vol. 34, No. 7, July 1989, pp 745-751.

Definition at line 292 of file ztgsyl.f.

295*
296* -- LAPACK computational routine --
297* -- LAPACK is a software package provided by Univ. of Tennessee, --
298* -- Univ. of California Berkeley, Univ. of Colorado Denver and NAG Ltd..--
299*
300* .. Scalar Arguments ..
301 CHARACTER TRANS
302 INTEGER IJOB, INFO, LDA, LDB, LDC, LDD, LDE, LDF,
303 \$ LWORK, M, N
304 DOUBLE PRECISION DIF, SCALE
305* ..
306* .. Array Arguments ..
307 INTEGER IWORK( * )
308 COMPLEX*16 A( LDA, * ), B( LDB, * ), C( LDC, * ),
309 \$ D( LDD, * ), E( LDE, * ), F( LDF, * ),
310 \$ WORK( * )
311* ..
312*
313* =====================================================================
314* Replaced various illegal calls to CCOPY by calls to CLASET.
315* Sven Hammarling, 1/5/02.
316*
317* .. Parameters ..
318 DOUBLE PRECISION ZERO, ONE
319 parameter( zero = 0.0d+0, one = 1.0d+0 )
320 COMPLEX*16 CZERO
321 parameter( czero = (0.0d+0, 0.0d+0) )
322* ..
323* .. Local Scalars ..
324 LOGICAL LQUERY, NOTRAN
325 INTEGER I, IE, IFUNC, IROUND, IS, ISOLVE, J, JE, JS, K,
326 \$ LINFO, LWMIN, MB, NB, P, PQ, Q
327 DOUBLE PRECISION DSCALE, DSUM, SCALE2, SCALOC
328* ..
329* .. External Functions ..
330 LOGICAL LSAME
331 INTEGER ILAENV
332 EXTERNAL lsame, ilaenv
333* ..
334* .. External Subroutines ..
335 EXTERNAL xerbla, zgemm, zlacpy, zlaset, zscal, ztgsy2
336* ..
337* .. Intrinsic Functions ..
338 INTRINSIC dble, dcmplx, max, sqrt
339* ..
340* .. Executable Statements ..
341*
342* Decode and test input parameters
343*
344 info = 0
345 notran = lsame( trans, 'N' )
346 lquery = ( lwork.EQ.-1 )
347*
348 IF( .NOT.notran .AND. .NOT.lsame( trans, 'C' ) ) THEN
349 info = -1
350 ELSE IF( notran ) THEN
351 IF( ( ijob.LT.0 ) .OR. ( ijob.GT.4 ) ) THEN
352 info = -2
353 END IF
354 END IF
355 IF( info.EQ.0 ) THEN
356 IF( m.LE.0 ) THEN
357 info = -3
358 ELSE IF( n.LE.0 ) THEN
359 info = -4
360 ELSE IF( lda.LT.max( 1, m ) ) THEN
361 info = -6
362 ELSE IF( ldb.LT.max( 1, n ) ) THEN
363 info = -8
364 ELSE IF( ldc.LT.max( 1, m ) ) THEN
365 info = -10
366 ELSE IF( ldd.LT.max( 1, m ) ) THEN
367 info = -12
368 ELSE IF( lde.LT.max( 1, n ) ) THEN
369 info = -14
370 ELSE IF( ldf.LT.max( 1, m ) ) THEN
371 info = -16
372 END IF
373 END IF
374*
375 IF( info.EQ.0 ) THEN
376 IF( notran ) THEN
377 IF( ijob.EQ.1 .OR. ijob.EQ.2 ) THEN
378 lwmin = max( 1, 2*m*n )
379 ELSE
380 lwmin = 1
381 END IF
382 ELSE
383 lwmin = 1
384 END IF
385 work( 1 ) = lwmin
386*
387 IF( lwork.LT.lwmin .AND. .NOT.lquery ) THEN
388 info = -20
389 END IF
390 END IF
391*
392 IF( info.NE.0 ) THEN
393 CALL xerbla( 'ZTGSYL', -info )
394 RETURN
395 ELSE IF( lquery ) THEN
396 RETURN
397 END IF
398*
399* Quick return if possible
400*
401 IF( m.EQ.0 .OR. n.EQ.0 ) THEN
402 scale = 1
403 IF( notran ) THEN
404 IF( ijob.NE.0 ) THEN
405 dif = 0
406 END IF
407 END IF
408 RETURN
409 END IF
410*
411* Determine optimal block sizes MB and NB
412*
413 mb = ilaenv( 2, 'ZTGSYL', trans, m, n, -1, -1 )
414 nb = ilaenv( 5, 'ZTGSYL', trans, m, n, -1, -1 )
415*
416 isolve = 1
417 ifunc = 0
418 IF( notran ) THEN
419 IF( ijob.GE.3 ) THEN
420 ifunc = ijob - 2
421 CALL zlaset( 'F', m, n, czero, czero, c, ldc )
422 CALL zlaset( 'F', m, n, czero, czero, f, ldf )
423 ELSE IF( ijob.GE.1 .AND. notran ) THEN
424 isolve = 2
425 END IF
426 END IF
427*
428 IF( ( mb.LE.1 .AND. nb.LE.1 ) .OR. ( mb.GE.m .AND. nb.GE.n ) )
429 \$ THEN
430*
431* Use unblocked Level 2 solver
432*
433 DO 30 iround = 1, isolve
434*
435 scale = one
436 dscale = zero
437 dsum = one
438 pq = m*n
439 CALL ztgsy2( trans, ifunc, m, n, a, lda, b, ldb, c, ldc, d,
440 \$ ldd, e, lde, f, ldf, scale, dsum, dscale,
441 \$ info )
442 IF( dscale.NE.zero ) THEN
443 IF( ijob.EQ.1 .OR. ijob.EQ.3 ) THEN
444 dif = sqrt( dble( 2*m*n ) ) / ( dscale*sqrt( dsum ) )
445 ELSE
446 dif = sqrt( dble( pq ) ) / ( dscale*sqrt( dsum ) )
447 END IF
448 END IF
449 IF( isolve.EQ.2 .AND. iround.EQ.1 ) THEN
450 IF( notran ) THEN
451 ifunc = ijob
452 END IF
453 scale2 = scale
454 CALL zlacpy( 'F', m, n, c, ldc, work, m )
455 CALL zlacpy( 'F', m, n, f, ldf, work( m*n+1 ), m )
456 CALL zlaset( 'F', m, n, czero, czero, c, ldc )
457 CALL zlaset( 'F', m, n, czero, czero, f, ldf )
458 ELSE IF( isolve.EQ.2 .AND. iround.EQ.2 ) THEN
459 CALL zlacpy( 'F', m, n, work, m, c, ldc )
460 CALL zlacpy( 'F', m, n, work( m*n+1 ), m, f, ldf )
461 scale = scale2
462 END IF
463 30 CONTINUE
464*
465 RETURN
466*
467 END IF
468*
469* Determine block structure of A
470*
471 p = 0
472 i = 1
473 40 CONTINUE
474 IF( i.GT.m )
475 \$ GO TO 50
476 p = p + 1
477 iwork( p ) = i
478 i = i + mb
479 IF( i.GE.m )
480 \$ GO TO 50
481 GO TO 40
482 50 CONTINUE
483 iwork( p+1 ) = m + 1
484 IF( iwork( p ).EQ.iwork( p+1 ) )
485 \$ p = p - 1
486*
487* Determine block structure of B
488*
489 q = p + 1
490 j = 1
491 60 CONTINUE
492 IF( j.GT.n )
493 \$ GO TO 70
494*
495 q = q + 1
496 iwork( q ) = j
497 j = j + nb
498 IF( j.GE.n )
499 \$ GO TO 70
500 GO TO 60
501*
502 70 CONTINUE
503 iwork( q+1 ) = n + 1
504 IF( iwork( q ).EQ.iwork( q+1 ) )
505 \$ q = q - 1
506*
507 IF( notran ) THEN
508 DO 150 iround = 1, isolve
509*
510* Solve (I, J) - subsystem
511* A(I, I) * R(I, J) - L(I, J) * B(J, J) = C(I, J)
512* D(I, I) * R(I, J) - L(I, J) * E(J, J) = F(I, J)
513* for I = P, P - 1, ..., 1; J = 1, 2, ..., Q
514*
515 pq = 0
516 scale = one
517 dscale = zero
518 dsum = one
519 DO 130 j = p + 2, q
520 js = iwork( j )
521 je = iwork( j+1 ) - 1
522 nb = je - js + 1
523 DO 120 i = p, 1, -1
524 is = iwork( i )
525 ie = iwork( i+1 ) - 1
526 mb = ie - is + 1
527 CALL ztgsy2( trans, ifunc, mb, nb, a( is, is ), lda,
528 \$ b( js, js ), ldb, c( is, js ), ldc,
529 \$ d( is, is ), ldd, e( js, js ), lde,
530 \$ f( is, js ), ldf, scaloc, dsum, dscale,
531 \$ linfo )
532 IF( linfo.GT.0 )
533 \$ info = linfo
534 pq = pq + mb*nb
535 IF( scaloc.NE.one ) THEN
536 DO 80 k = 1, js - 1
537 CALL zscal( m, dcmplx( scaloc, zero ),
538 \$ c( 1, k ), 1 )
539 CALL zscal( m, dcmplx( scaloc, zero ),
540 \$ f( 1, k ), 1 )
541 80 CONTINUE
542 DO 90 k = js, je
543 CALL zscal( is-1, dcmplx( scaloc, zero ),
544 \$ c( 1, k ), 1 )
545 CALL zscal( is-1, dcmplx( scaloc, zero ),
546 \$ f( 1, k ), 1 )
547 90 CONTINUE
548 DO 100 k = js, je
549 CALL zscal( m-ie, dcmplx( scaloc, zero ),
550 \$ c( ie+1, k ), 1 )
551 CALL zscal( m-ie, dcmplx( scaloc, zero ),
552 \$ f( ie+1, k ), 1 )
553 100 CONTINUE
554 DO 110 k = je + 1, n
555 CALL zscal( m, dcmplx( scaloc, zero ),
556 \$ c( 1, k ), 1 )
557 CALL zscal( m, dcmplx( scaloc, zero ),
558 \$ f( 1, k ), 1 )
559 110 CONTINUE
560 scale = scale*scaloc
561 END IF
562*
563* Substitute R(I,J) and L(I,J) into remaining equation.
564*
565 IF( i.GT.1 ) THEN
566 CALL zgemm( 'N', 'N', is-1, nb, mb,
567 \$ dcmplx( -one, zero ), a( 1, is ), lda,
568 \$ c( is, js ), ldc, dcmplx( one, zero ),
569 \$ c( 1, js ), ldc )
570 CALL zgemm( 'N', 'N', is-1, nb, mb,
571 \$ dcmplx( -one, zero ), d( 1, is ), ldd,
572 \$ c( is, js ), ldc, dcmplx( one, zero ),
573 \$ f( 1, js ), ldf )
574 END IF
575 IF( j.LT.q ) THEN
576 CALL zgemm( 'N', 'N', mb, n-je, nb,
577 \$ dcmplx( one, zero ), f( is, js ), ldf,
578 \$ b( js, je+1 ), ldb,
579 \$ dcmplx( one, zero ), c( is, je+1 ),
580 \$ ldc )
581 CALL zgemm( 'N', 'N', mb, n-je, nb,
582 \$ dcmplx( one, zero ), f( is, js ), ldf,
583 \$ e( js, je+1 ), lde,
584 \$ dcmplx( one, zero ), f( is, je+1 ),
585 \$ ldf )
586 END IF
587 120 CONTINUE
588 130 CONTINUE
589 IF( dscale.NE.zero ) THEN
590 IF( ijob.EQ.1 .OR. ijob.EQ.3 ) THEN
591 dif = sqrt( dble( 2*m*n ) ) / ( dscale*sqrt( dsum ) )
592 ELSE
593 dif = sqrt( dble( pq ) ) / ( dscale*sqrt( dsum ) )
594 END IF
595 END IF
596 IF( isolve.EQ.2 .AND. iround.EQ.1 ) THEN
597 IF( notran ) THEN
598 ifunc = ijob
599 END IF
600 scale2 = scale
601 CALL zlacpy( 'F', m, n, c, ldc, work, m )
602 CALL zlacpy( 'F', m, n, f, ldf, work( m*n+1 ), m )
603 CALL zlaset( 'F', m, n, czero, czero, c, ldc )
604 CALL zlaset( 'F', m, n, czero, czero, f, ldf )
605 ELSE IF( isolve.EQ.2 .AND. iround.EQ.2 ) THEN
606 CALL zlacpy( 'F', m, n, work, m, c, ldc )
607 CALL zlacpy( 'F', m, n, work( m*n+1 ), m, f, ldf )
608 scale = scale2
609 END IF
610 150 CONTINUE
611 ELSE
612*
613* Solve transposed (I, J)-subsystem
614* A(I, I)**H * R(I, J) + D(I, I)**H * L(I, J) = C(I, J)
615* R(I, J) * B(J, J) + L(I, J) * E(J, J) = -F(I, J)
616* for I = 1,2,..., P; J = Q, Q-1,..., 1
617*
618 scale = one
619 DO 210 i = 1, p
620 is = iwork( i )
621 ie = iwork( i+1 ) - 1
622 mb = ie - is + 1
623 DO 200 j = q, p + 2, -1
624 js = iwork( j )
625 je = iwork( j+1 ) - 1
626 nb = je - js + 1
627 CALL ztgsy2( trans, ifunc, mb, nb, a( is, is ), lda,
628 \$ b( js, js ), ldb, c( is, js ), ldc,
629 \$ d( is, is ), ldd, e( js, js ), lde,
630 \$ f( is, js ), ldf, scaloc, dsum, dscale,
631 \$ linfo )
632 IF( linfo.GT.0 )
633 \$ info = linfo
634 IF( scaloc.NE.one ) THEN
635 DO 160 k = 1, js - 1
636 CALL zscal( m, dcmplx( scaloc, zero ), c( 1, k ),
637 \$ 1 )
638 CALL zscal( m, dcmplx( scaloc, zero ), f( 1, k ),
639 \$ 1 )
640 160 CONTINUE
641 DO 170 k = js, je
642 CALL zscal( is-1, dcmplx( scaloc, zero ),
643 \$ c( 1, k ), 1 )
644 CALL zscal( is-1, dcmplx( scaloc, zero ),
645 \$ f( 1, k ), 1 )
646 170 CONTINUE
647 DO 180 k = js, je
648 CALL zscal( m-ie, dcmplx( scaloc, zero ),
649 \$ c( ie+1, k ), 1 )
650 CALL zscal( m-ie, dcmplx( scaloc, zero ),
651 \$ f( ie+1, k ), 1 )
652 180 CONTINUE
653 DO 190 k = je + 1, n
654 CALL zscal( m, dcmplx( scaloc, zero ), c( 1, k ),
655 \$ 1 )
656 CALL zscal( m, dcmplx( scaloc, zero ), f( 1, k ),
657 \$ 1 )
658 190 CONTINUE
659 scale = scale*scaloc
660 END IF
661*
662* Substitute R(I,J) and L(I,J) into remaining equation.
663*
664 IF( j.GT.p+2 ) THEN
665 CALL zgemm( 'N', 'C', mb, js-1, nb,
666 \$ dcmplx( one, zero ), c( is, js ), ldc,
667 \$ b( 1, js ), ldb, dcmplx( one, zero ),
668 \$ f( is, 1 ), ldf )
669 CALL zgemm( 'N', 'C', mb, js-1, nb,
670 \$ dcmplx( one, zero ), f( is, js ), ldf,
671 \$ e( 1, js ), lde, dcmplx( one, zero ),
672 \$ f( is, 1 ), ldf )
673 END IF
674 IF( i.LT.p ) THEN
675 CALL zgemm( 'C', 'N', m-ie, nb, mb,
676 \$ dcmplx( -one, zero ), a( is, ie+1 ), lda,
677 \$ c( is, js ), ldc, dcmplx( one, zero ),
678 \$ c( ie+1, js ), ldc )
679 CALL zgemm( 'C', 'N', m-ie, nb, mb,
680 \$ dcmplx( -one, zero ), d( is, ie+1 ), ldd,
681 \$ f( is, js ), ldf, dcmplx( one, zero ),
682 \$ c( ie+1, js ), ldc )
683 END IF
684 200 CONTINUE
685 210 CONTINUE
686 END IF
687*
688 work( 1 ) = lwmin
689*
690 RETURN
691*
692* End of ZTGSYL
693*
logical function lde(RI, RJ, LR)
Definition: dblat2.f:2970
integer function ilaenv(ISPEC, NAME, OPTS, N1, N2, N3, N4)
ILAENV
Definition: ilaenv.f:162
subroutine xerbla(SRNAME, INFO)
XERBLA
Definition: xerbla.f:60
logical function lsame(CA, CB)
LSAME
Definition: lsame.f:53
subroutine zscal(N, ZA, ZX, INCX)
ZSCAL
Definition: zscal.f:78
subroutine zgemm(TRANSA, TRANSB, M, N, K, ALPHA, A, LDA, B, LDB, BETA, C, LDC)
ZGEMM
Definition: zgemm.f:187
subroutine zlacpy(UPLO, M, N, A, LDA, B, LDB)
ZLACPY copies all or part of one two-dimensional array to another.
Definition: zlacpy.f:103
subroutine zlaset(UPLO, M, N, ALPHA, BETA, A, LDA)
ZLASET initializes the off-diagonal elements and the diagonal elements of a matrix to given values.
Definition: zlaset.f:106
subroutine ztgsy2(TRANS, IJOB, M, N, A, LDA, B, LDB, C, LDC, D, LDD, E, LDE, F, LDF, SCALE, RDSUM, RDSCAL, INFO)
ZTGSY2 solves the generalized Sylvester equation (unblocked algorithm).
Definition: ztgsy2.f:259
Here is the call graph for this function:
Here is the caller graph for this function: