LAPACK 3.11.0
LAPACK: Linear Algebra PACKage
Loading...
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

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

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.
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 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: