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

◆ stgsyl()

subroutine stgsyl ( 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 dif,
real, dimension( * ) work,
integer lwork,
integer, dimension( * ) iwork,
integer info )

STGSYL

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

Purpose:
!>
!> STGSYL 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 real entries. (A, D) and (B, E) must be in
!> generalized (real) 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 (1) is equivalent to solve  Zx = scale b, where
!> Z is defined as
!>
!>            Z = [ kron(In, A)  -kron(B**T, Im) ]         (2)
!>                [ kron(In, D)  -kron(E**T, Im) ].
!>
!> Here 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.
!>
!> If TRANS = 'T', STGSYL solves the transposed system Z**T*y = scale*b,
!> 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 (TRANS = 'T') 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 SLACON.
!>
!> If IJOB >= 1, STGSYL 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. See [1-2] for more
!> information.
!>
!> This is a level 3 BLAS algorithm.
!>
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: 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 IJOB  = 1 is used).
!>          = 4: Only an estimate of Dif[(A,D), (B,E)] is computed.
!>               ( SGECON on sub-systems is used ).
!>          Not referenced if TRANS = 'T'.
!>
[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 REAL array, dimension (LDA, M)
!>          The upper quasi triangular matrix A.
!>
[in]LDA
!>          LDA is INTEGER
!>          The leading dimension of the array A. LDA >= max(1, M).
!>
[in]B
!>          B is REAL array, dimension (LDB, N)
!>          The upper quasi triangular matrix B.
!>
[in]LDB
!>          LDB is INTEGER
!>          The leading dimension of the array 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) 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 REAL 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 REAL 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 REAL 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 = 'T', DIF is not touched.
!>
[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, C and F hold the
!>          solutions R and L, respectively, to the homogeneous system
!>          with C = F = 0. Normally, SCALE = 1.
!>
[out]WORK
!>          WORK is REAL 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+6)
!>
[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 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 294 of file stgsyl.f.

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