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

◆ ctgsyl()

subroutine ctgsyl ( 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  DIF,
complex, dimension( * )  WORK,
integer  LWORK,
integer, dimension( * )  IWORK,
integer  INFO 
)

CTGSYL

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

Purpose:
 CTGSYL 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 CLACON.

 If IJOB >= 1, CTGSYL 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.
              (CGECON 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 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 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 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 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 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 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 REAL
          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 REAL
          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 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.
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.
References:
[1] 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.
[2] 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.
[3] 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 ctgsyl.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 REAL DIF, SCALE
305* ..
306* .. Array Arguments ..
307 INTEGER IWORK( * )
308 COMPLEX 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 REAL ZERO, ONE
319 parameter( zero = 0.0e+0, one = 1.0e+0 )
320 COMPLEX CZERO
321 parameter( czero = (0.0e+0, 0.0e+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 REAL DSCALE, DSUM, SCALE2, SCALOC
328* ..
329* .. External Functions ..
330 LOGICAL LSAME
331 INTEGER ILAENV
332 EXTERNAL lsame, ilaenv
333* ..
334* .. External Subroutines ..
335 EXTERNAL cgemm, clacpy, claset, cscal, ctgsy2, xerbla
336* ..
337* .. Intrinsic Functions ..
338 INTRINSIC cmplx, max, real, 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( 'CTGSYL', -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, 'CTGSYL', trans, m, n, -1, -1 )
414 nb = ilaenv( 5, 'CTGSYL', 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 claset( 'F', m, n, czero, czero, c, ldc )
422 CALL claset( '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 ctgsy2( 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( real( 2*m*n ) ) / ( dscale*sqrt( dsum ) )
445 ELSE
446 dif = sqrt( real( 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 clacpy( 'F', m, n, c, ldc, work, m )
455 CALL clacpy( 'F', m, n, f, ldf, work( m*n+1 ), m )
456 CALL claset( 'F', m, n, czero, czero, c, ldc )
457 CALL claset( 'F', m, n, czero, czero, f, ldf )
458 ELSE IF( isolve.EQ.2 .AND. iround.EQ.2 ) THEN
459 CALL clacpy( 'F', m, n, work, m, c, ldc )
460 CALL clacpy( '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 ctgsy2( 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 cscal( m, cmplx( scaloc, zero ), c( 1, k ),
538 $ 1 )
539 CALL cscal( m, cmplx( scaloc, zero ), f( 1, k ),
540 $ 1 )
541 80 CONTINUE
542 DO 90 k = js, je
543 CALL cscal( is-1, cmplx( scaloc, zero ),
544 $ c( 1, k ), 1 )
545 CALL cscal( is-1, cmplx( scaloc, zero ),
546 $ f( 1, k ), 1 )
547 90 CONTINUE
548 DO 100 k = js, je
549 CALL cscal( m-ie, cmplx( scaloc, zero ),
550 $ c( ie+1, k ), 1 )
551 CALL cscal( m-ie, cmplx( scaloc, zero ),
552 $ f( ie+1, k ), 1 )
553 100 CONTINUE
554 DO 110 k = je + 1, n
555 CALL cscal( m, cmplx( scaloc, zero ), c( 1, k ),
556 $ 1 )
557 CALL cscal( m, cmplx( scaloc, zero ), f( 1, k ),
558 $ 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 cgemm( 'N', 'N', is-1, nb, mb,
567 $ cmplx( -one, zero ), a( 1, is ), lda,
568 $ c( is, js ), ldc, cmplx( one, zero ),
569 $ c( 1, js ), ldc )
570 CALL cgemm( 'N', 'N', is-1, nb, mb,
571 $ cmplx( -one, zero ), d( 1, is ), ldd,
572 $ c( is, js ), ldc, cmplx( one, zero ),
573 $ f( 1, js ), ldf )
574 END IF
575 IF( j.LT.q ) THEN
576 CALL cgemm( 'N', 'N', mb, n-je, nb,
577 $ cmplx( one, zero ), f( is, js ), ldf,
578 $ b( js, je+1 ), ldb, cmplx( one, zero ),
579 $ c( is, je+1 ), ldc )
580 CALL cgemm( 'N', 'N', mb, n-je, nb,
581 $ cmplx( one, zero ), f( is, js ), ldf,
582 $ e( js, je+1 ), lde, cmplx( one, zero ),
583 $ f( is, je+1 ), ldf )
584 END IF
585 120 CONTINUE
586 130 CONTINUE
587 IF( dscale.NE.zero ) THEN
588 IF( ijob.EQ.1 .OR. ijob.EQ.3 ) THEN
589 dif = sqrt( real( 2*m*n ) ) / ( dscale*sqrt( dsum ) )
590 ELSE
591 dif = sqrt( real( pq ) ) / ( dscale*sqrt( dsum ) )
592 END IF
593 END IF
594 IF( isolve.EQ.2 .AND. iround.EQ.1 ) THEN
595 IF( notran ) THEN
596 ifunc = ijob
597 END IF
598 scale2 = scale
599 CALL clacpy( 'F', m, n, c, ldc, work, m )
600 CALL clacpy( 'F', m, n, f, ldf, work( m*n+1 ), m )
601 CALL claset( 'F', m, n, czero, czero, c, ldc )
602 CALL claset( 'F', m, n, czero, czero, f, ldf )
603 ELSE IF( isolve.EQ.2 .AND. iround.EQ.2 ) THEN
604 CALL clacpy( 'F', m, n, work, m, c, ldc )
605 CALL clacpy( 'F', m, n, work( m*n+1 ), m, f, ldf )
606 scale = scale2
607 END IF
608 150 CONTINUE
609 ELSE
610*
611* Solve transposed (I, J)-subsystem
612* A(I, I)**H * R(I, J) + D(I, I)**H * L(I, J) = C(I, J)
613* R(I, J) * B(J, J) + L(I, J) * E(J, J) = -F(I, J)
614* for I = 1,2,..., P; J = Q, Q-1,..., 1
615*
616 scale = one
617 DO 210 i = 1, p
618 is = iwork( i )
619 ie = iwork( i+1 ) - 1
620 mb = ie - is + 1
621 DO 200 j = q, p + 2, -1
622 js = iwork( j )
623 je = iwork( j+1 ) - 1
624 nb = je - js + 1
625 CALL ctgsy2( trans, ifunc, mb, nb, a( is, is ), lda,
626 $ b( js, js ), ldb, c( is, js ), ldc,
627 $ d( is, is ), ldd, e( js, js ), lde,
628 $ f( is, js ), ldf, scaloc, dsum, dscale,
629 $ linfo )
630 IF( linfo.GT.0 )
631 $ info = linfo
632 IF( scaloc.NE.one ) THEN
633 DO 160 k = 1, js - 1
634 CALL cscal( m, cmplx( scaloc, zero ), c( 1, k ),
635 $ 1 )
636 CALL cscal( m, cmplx( scaloc, zero ), f( 1, k ),
637 $ 1 )
638 160 CONTINUE
639 DO 170 k = js, je
640 CALL cscal( is-1, cmplx( scaloc, zero ), c( 1, k ),
641 $ 1 )
642 CALL cscal( is-1, cmplx( scaloc, zero ), f( 1, k ),
643 $ 1 )
644 170 CONTINUE
645 DO 180 k = js, je
646 CALL cscal( m-ie, cmplx( scaloc, zero ),
647 $ c( ie+1, k ), 1 )
648 CALL cscal( m-ie, cmplx( scaloc, zero ),
649 $ f( ie+1, k ), 1 )
650 180 CONTINUE
651 DO 190 k = je + 1, n
652 CALL cscal( m, cmplx( scaloc, zero ), c( 1, k ),
653 $ 1 )
654 CALL cscal( m, cmplx( scaloc, zero ), f( 1, k ),
655 $ 1 )
656 190 CONTINUE
657 scale = scale*scaloc
658 END IF
659*
660* Substitute R(I,J) and L(I,J) into remaining equation.
661*
662 IF( j.GT.p+2 ) THEN
663 CALL cgemm( 'N', 'C', mb, js-1, nb,
664 $ cmplx( one, zero ), c( is, js ), ldc,
665 $ b( 1, js ), ldb, cmplx( one, zero ),
666 $ f( is, 1 ), ldf )
667 CALL cgemm( 'N', 'C', mb, js-1, nb,
668 $ cmplx( one, zero ), f( is, js ), ldf,
669 $ e( 1, js ), lde, cmplx( one, zero ),
670 $ f( is, 1 ), ldf )
671 END IF
672 IF( i.LT.p ) THEN
673 CALL cgemm( 'C', 'N', m-ie, nb, mb,
674 $ cmplx( -one, zero ), a( is, ie+1 ), lda,
675 $ c( is, js ), ldc, cmplx( one, zero ),
676 $ c( ie+1, js ), ldc )
677 CALL cgemm( 'C', 'N', m-ie, nb, mb,
678 $ cmplx( -one, zero ), d( is, ie+1 ), ldd,
679 $ f( is, js ), ldf, cmplx( one, zero ),
680 $ c( ie+1, js ), ldc )
681 END IF
682 200 CONTINUE
683 210 CONTINUE
684 END IF
685*
686 work( 1 ) = lwmin
687*
688 RETURN
689*
690* End of CTGSYL
691*
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 cscal(N, CA, CX, INCX)
CSCAL
Definition: cscal.f:78
subroutine cgemm(TRANSA, TRANSB, M, N, K, ALPHA, A, LDA, B, LDB, BETA, C, LDC)
CGEMM
Definition: cgemm.f:187
subroutine claset(UPLO, M, N, ALPHA, BETA, A, LDA)
CLASET initializes the off-diagonal elements and the diagonal elements of a matrix to given values.
Definition: claset.f:106
subroutine clacpy(UPLO, M, N, A, LDA, B, LDB)
CLACPY copies all or part of one two-dimensional array to another.
Definition: clacpy.f:103
subroutine ctgsy2(TRANS, IJOB, M, N, A, LDA, B, LDB, C, LDC, D, LDD, E, LDE, F, LDF, SCALE, RDSUM, RDSCAL, INFO)
CTGSY2 solves the generalized Sylvester equation (unblocked algorithm).
Definition: ctgsy2.f:259
Here is the call graph for this function:
Here is the caller graph for this function: