LAPACK  3.8.0
LAPACK: Linear Algebra PACKage

◆ dtgsna()

subroutine dtgsna ( character  JOB,
character  HOWMNY,
logical, dimension( * )  SELECT,
integer  N,
double precision, dimension( lda, * )  A,
integer  LDA,
double precision, dimension( ldb, * )  B,
integer  LDB,
double precision, dimension( ldvl, * )  VL,
integer  LDVL,
double precision, dimension( ldvr, * )  VR,
integer  LDVR,
double precision, dimension( * )  S,
double precision, dimension( * )  DIF,
integer  MM,
integer  M,
double precision, dimension( * )  WORK,
integer  LWORK,
integer, dimension( * )  IWORK,
integer  INFO 
)

DTGSNA

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

Purpose:
 DTGSNA estimates reciprocal condition numbers for specified
 eigenvalues and/or eigenvectors of a matrix pair (A, B) in
 generalized real Schur canonical form (or of any matrix pair
 (Q*A*Z**T, Q*B*Z**T) with orthogonal matrices Q and Z, where
 Z**T denotes the transpose of Z.

 (A, B) must be in generalized real Schur form (as returned by DGGES),
 i.e. A is block upper triangular with 1-by-1 and 2-by-2 diagonal
 blocks. B is upper triangular.
Parameters
[in]JOB
          JOB is CHARACTER*1
          Specifies whether condition numbers are required for
          eigenvalues (S) or eigenvectors (DIF):
          = 'E': for eigenvalues only (S);
          = 'V': for eigenvectors only (DIF);
          = 'B': for both eigenvalues and eigenvectors (S and DIF).
[in]HOWMNY
          HOWMNY is CHARACTER*1
          = 'A': compute condition numbers for all eigenpairs;
          = 'S': compute condition numbers for selected eigenpairs
                 specified by the array SELECT.
[in]SELECT
          SELECT is LOGICAL array, dimension (N)
          If HOWMNY = 'S', SELECT specifies the eigenpairs for which
          condition numbers are required. To select condition numbers
          for the eigenpair corresponding to a real eigenvalue w(j),
          SELECT(j) must be set to .TRUE.. To select condition numbers
          corresponding to a complex conjugate pair of eigenvalues w(j)
          and w(j+1), either SELECT(j) or SELECT(j+1) or both, must be
          set to .TRUE..
          If HOWMNY = 'A', SELECT is not referenced.
[in]N
          N is INTEGER
          The order of the square matrix pair (A, B). N >= 0.
[in]A
          A is DOUBLE PRECISION array, dimension (LDA,N)
          The upper quasi-triangular matrix A in the pair (A,B).
[in]LDA
          LDA is INTEGER
          The leading dimension of the array A. LDA >= max(1,N).
[in]B
          B is DOUBLE PRECISION array, dimension (LDB,N)
          The upper triangular matrix B in the pair (A,B).
[in]LDB
          LDB is INTEGER
          The leading dimension of the array B. LDB >= max(1,N).
[in]VL
          VL is DOUBLE PRECISION array, dimension (LDVL,M)
          If JOB = 'E' or 'B', VL must contain left eigenvectors of
          (A, B), corresponding to the eigenpairs specified by HOWMNY
          and SELECT. The eigenvectors must be stored in consecutive
          columns of VL, as returned by DTGEVC.
          If JOB = 'V', VL is not referenced.
[in]LDVL
          LDVL is INTEGER
          The leading dimension of the array VL. LDVL >= 1.
          If JOB = 'E' or 'B', LDVL >= N.
[in]VR
          VR is DOUBLE PRECISION array, dimension (LDVR,M)
          If JOB = 'E' or 'B', VR must contain right eigenvectors of
          (A, B), corresponding to the eigenpairs specified by HOWMNY
          and SELECT. The eigenvectors must be stored in consecutive
          columns ov VR, as returned by DTGEVC.
          If JOB = 'V', VR is not referenced.
[in]LDVR
          LDVR is INTEGER
          The leading dimension of the array VR. LDVR >= 1.
          If JOB = 'E' or 'B', LDVR >= N.
[out]S
          S is DOUBLE PRECISION array, dimension (MM)
          If JOB = 'E' or 'B', the reciprocal condition numbers of the
          selected eigenvalues, stored in consecutive elements of the
          array. For a complex conjugate pair of eigenvalues two
          consecutive elements of S are set to the same value. Thus
          S(j), DIF(j), and the j-th columns of VL and VR all
          correspond to the same eigenpair (but not in general the
          j-th eigenpair, unless all eigenpairs are selected).
          If JOB = 'V', S is not referenced.
[out]DIF
          DIF is DOUBLE PRECISION array, dimension (MM)
          If JOB = 'V' or 'B', the estimated reciprocal condition
          numbers of the selected eigenvectors, stored in consecutive
          elements of the array. For a complex eigenvector two
          consecutive elements of DIF are set to the same value. If
          the eigenvalues cannot be reordered to compute DIF(j), DIF(j)
          is set to 0; this can only occur when the true value would be
          very small anyway.
          If JOB = 'E', DIF is not referenced.
[in]MM
          MM is INTEGER
          The number of elements in the arrays S and DIF. MM >= M.
[out]M
          M is INTEGER
          The number of elements of the arrays S and DIF used to store
          the specified condition numbers; for each selected real
          eigenvalue one element is used, and for each selected complex
          conjugate pair of eigenvalues, two elements are used.
          If HOWMNY = 'A', M is set to N.
[out]WORK
          WORK is DOUBLE PRECISION 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 >= max(1,N).
          If JOB = 'V' or 'B' LWORK >= 2*N*(N+2)+16.

          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 (N + 6)
          If JOB = 'E', IWORK is not referenced.
[out]INFO
          INFO is INTEGER
          =0: Successful exit
          <0: If INFO = -i, the i-th argument had an illegal value
Author
Univ. of Tennessee
Univ. of California Berkeley
Univ. of Colorado Denver
NAG Ltd.
Date
December 2016
Further Details:
  The reciprocal of the condition number of a generalized eigenvalue
  w = (a, b) is defined as

       S(w) = (|u**TAv|**2 + |u**TBv|**2)**(1/2) / (norm(u)*norm(v))

  where u and v are the left and right eigenvectors of (A, B)
  corresponding to w; |z| denotes the absolute value of the complex
  number, and norm(u) denotes the 2-norm of the vector u.
  The pair (a, b) corresponds to an eigenvalue w = a/b (= u**TAv/u**TBv)
  of the matrix pair (A, B). If both a and b equal zero, then (A B) is
  singular and S(I) = -1 is returned.

  An approximate error bound on the chordal distance between the i-th
  computed generalized eigenvalue w and the corresponding exact
  eigenvalue lambda is

       chord(w, lambda) <= EPS * norm(A, B) / S(I)

  where EPS is the machine precision.

  The reciprocal of the condition number DIF(i) of right eigenvector u
  and left eigenvector v corresponding to the generalized eigenvalue w
  is defined as follows:

  a) If the i-th eigenvalue w = (a,b) is real

     Suppose U and V are orthogonal transformations such that

              U**T*(A, B)*V  = (S, T) = ( a   *  ) ( b  *  )  1
                                        ( 0  S22 ),( 0 T22 )  n-1
                                          1  n-1     1 n-1

     Then the reciprocal condition number DIF(i) is

                Difl((a, b), (S22, T22)) = sigma-min( Zl ),

     where sigma-min(Zl) denotes the smallest singular value of the
     2(n-1)-by-2(n-1) matrix

         Zl = [ kron(a, In-1)  -kron(1, S22) ]
              [ kron(b, In-1)  -kron(1, T22) ] .

     Here In-1 is the identity matrix of size n-1. kron(X, Y) is the
     Kronecker product between the matrices X and Y.

     Note that if the default method for computing DIF(i) is wanted
     (see DLATDF), then the parameter DIFDRI (see below) should be
     changed from 3 to 4 (routine DLATDF(IJOB = 2 will be used)).
     See DTGSYL for more details.

  b) If the i-th and (i+1)-th eigenvalues are complex conjugate pair,

     Suppose U and V are orthogonal transformations such that

              U**T*(A, B)*V = (S, T) = ( S11  *   ) ( T11  *  )  2
                                       ( 0    S22 ),( 0    T22) n-2
                                         2    n-2     2    n-2

     and (S11, T11) corresponds to the complex conjugate eigenvalue
     pair (w, conjg(w)). There exist unitary matrices U1 and V1 such
     that

       U1**T*S11*V1 = ( s11 s12 ) and U1**T*T11*V1 = ( t11 t12 )
                      (  0  s22 )                    (  0  t22 )

     where the generalized eigenvalues w = s11/t11 and
     conjg(w) = s22/t22.

     Then the reciprocal condition number DIF(i) is bounded by

         min( d1, max( 1, |real(s11)/real(s22)| )*d2 )

     where, d1 = Difl((s11, t11), (s22, t22)) = sigma-min(Z1), where
     Z1 is the complex 2-by-2 matrix

              Z1 =  [ s11  -s22 ]
                    [ t11  -t22 ],

     This is done by computing (using real arithmetic) the
     roots of the characteristical polynomial det(Z1**T * Z1 - lambda I),
     where Z1**T denotes the transpose of Z1 and det(X) denotes
     the determinant of X.

     and d2 is an upper bound on Difl((S11, T11), (S22, T22)), i.e. an
     upper bound on sigma-min(Z2), where Z2 is (2n-2)-by-(2n-2)

              Z2 = [ kron(S11**T, In-2)  -kron(I2, S22) ]
                   [ kron(T11**T, In-2)  -kron(I2, T22) ]

     Note that if the default method for computing DIF is wanted (see
     DLATDF), then the parameter DIFDRI (see below) should be changed
     from 3 to 4 (routine DLATDF(IJOB = 2 will be used)). See DTGSYL
     for more details.

  For each eigenvalue/vector specified by SELECT, DIF stores a
  Frobenius norm-based estimate of Difl.

  An approximate error bound for the i-th computed eigenvector VL(i) or
  VR(i) is given by

             EPS * norm(A, B) / DIF(i).

  See ref. [2-3] for more details and further references.
Contributors:
Bo Kagstrom and Peter Poromaa, Department of Computing Science, Umea University, S-901 87 Umea, Sweden.
References:
  [1] B. Kagstrom; A Direct Method for Reordering Eigenvalues in the
      Generalized Real Schur Form of a Regular Matrix Pair (A, B), in
      M.S. Moonen et al (eds), Linear Algebra for Large Scale and
      Real-Time Applications, Kluwer Academic Publ. 1993, pp 195-218.

  [2] B. Kagstrom and P. Poromaa; Computing Eigenspaces with Specified
      Eigenvalues of a Regular Matrix Pair (A, B) and Condition
      Estimation: Theory, Algorithms and Software,
      Report UMINF - 94.04, Department of Computing Science, Umea
      University, S-901 87 Umea, Sweden, 1994. Also as LAPACK Working
      Note 87. To appear in Numerical Algorithms, 1996.

  [3] 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.

Definition at line 383 of file dtgsna.f.

383 *
384 * -- LAPACK computational routine (version 3.7.0) --
385 * -- LAPACK is a software package provided by Univ. of Tennessee, --
386 * -- Univ. of California Berkeley, Univ. of Colorado Denver and NAG Ltd..--
387 * December 2016
388 *
389 * .. Scalar Arguments ..
390  CHARACTER howmny, job
391  INTEGER info, lda, ldb, ldvl, ldvr, lwork, m, mm, n
392 * ..
393 * .. Array Arguments ..
394  LOGICAL select( * )
395  INTEGER iwork( * )
396  DOUBLE PRECISION a( lda, * ), b( ldb, * ), dif( * ), s( * ),
397  $ vl( ldvl, * ), vr( ldvr, * ), work( * )
398 * ..
399 *
400 * =====================================================================
401 *
402 * .. Parameters ..
403  INTEGER difdri
404  parameter( difdri = 3 )
405  DOUBLE PRECISION zero, one, two, four
406  parameter( zero = 0.0d+0, one = 1.0d+0, two = 2.0d+0,
407  $ four = 4.0d+0 )
408 * ..
409 * .. Local Scalars ..
410  LOGICAL lquery, pair, somcon, wantbh, wantdf, wants
411  INTEGER i, ierr, ifst, ilst, iz, k, ks, lwmin, n1, n2
412  DOUBLE PRECISION alphai, alphar, alprqt, beta, c1, c2, cond,
413  $ eps, lnrm, rnrm, root1, root2, scale, smlnum,
414  $ tmpii, tmpir, tmpri, tmprr, uhav, uhavi, uhbv,
415  $ uhbvi
416 * ..
417 * .. Local Arrays ..
418  DOUBLE PRECISION dummy( 1 ), dummy1( 1 )
419 * ..
420 * .. External Functions ..
421  LOGICAL lsame
422  DOUBLE PRECISION ddot, dlamch, dlapy2, dnrm2
423  EXTERNAL lsame, ddot, dlamch, dlapy2, dnrm2
424 * ..
425 * .. External Subroutines ..
426  EXTERNAL dgemv, dlacpy, dlag2, dtgexc, dtgsyl, xerbla
427 * ..
428 * .. Intrinsic Functions ..
429  INTRINSIC max, min, sqrt
430 * ..
431 * .. Executable Statements ..
432 *
433 * Decode and test the input parameters
434 *
435  wantbh = lsame( job, 'B' )
436  wants = lsame( job, 'E' ) .OR. wantbh
437  wantdf = lsame( job, 'V' ) .OR. wantbh
438 *
439  somcon = lsame( howmny, 'S' )
440 *
441  info = 0
442  lquery = ( lwork.EQ.-1 )
443 *
444  IF( .NOT.wants .AND. .NOT.wantdf ) THEN
445  info = -1
446  ELSE IF( .NOT.lsame( howmny, 'A' ) .AND. .NOT.somcon ) THEN
447  info = -2
448  ELSE IF( n.LT.0 ) THEN
449  info = -4
450  ELSE IF( lda.LT.max( 1, n ) ) THEN
451  info = -6
452  ELSE IF( ldb.LT.max( 1, n ) ) THEN
453  info = -8
454  ELSE IF( wants .AND. ldvl.LT.n ) THEN
455  info = -10
456  ELSE IF( wants .AND. ldvr.LT.n ) THEN
457  info = -12
458  ELSE
459 *
460 * Set M to the number of eigenpairs for which condition numbers
461 * are required, and test MM.
462 *
463  IF( somcon ) THEN
464  m = 0
465  pair = .false.
466  DO 10 k = 1, n
467  IF( pair ) THEN
468  pair = .false.
469  ELSE
470  IF( k.LT.n ) THEN
471  IF( a( k+1, k ).EQ.zero ) THEN
472  IF( SELECT( k ) )
473  $ m = m + 1
474  ELSE
475  pair = .true.
476  IF( SELECT( k ) .OR. SELECT( k+1 ) )
477  $ m = m + 2
478  END IF
479  ELSE
480  IF( SELECT( n ) )
481  $ m = m + 1
482  END IF
483  END IF
484  10 CONTINUE
485  ELSE
486  m = n
487  END IF
488 *
489  IF( n.EQ.0 ) THEN
490  lwmin = 1
491  ELSE IF( lsame( job, 'V' ) .OR. lsame( job, 'B' ) ) THEN
492  lwmin = 2*n*( n + 2 ) + 16
493  ELSE
494  lwmin = n
495  END IF
496  work( 1 ) = lwmin
497 *
498  IF( mm.LT.m ) THEN
499  info = -15
500  ELSE IF( lwork.LT.lwmin .AND. .NOT.lquery ) THEN
501  info = -18
502  END IF
503  END IF
504 *
505  IF( info.NE.0 ) THEN
506  CALL xerbla( 'DTGSNA', -info )
507  RETURN
508  ELSE IF( lquery ) THEN
509  RETURN
510  END IF
511 *
512 * Quick return if possible
513 *
514  IF( n.EQ.0 )
515  $ RETURN
516 *
517 * Get machine constants
518 *
519  eps = dlamch( 'P' )
520  smlnum = dlamch( 'S' ) / eps
521  ks = 0
522  pair = .false.
523 *
524  DO 20 k = 1, n
525 *
526 * Determine whether A(k,k) begins a 1-by-1 or 2-by-2 block.
527 *
528  IF( pair ) THEN
529  pair = .false.
530  GO TO 20
531  ELSE
532  IF( k.LT.n )
533  $ pair = a( k+1, k ).NE.zero
534  END IF
535 *
536 * Determine whether condition numbers are required for the k-th
537 * eigenpair.
538 *
539  IF( somcon ) THEN
540  IF( pair ) THEN
541  IF( .NOT.SELECT( k ) .AND. .NOT.SELECT( k+1 ) )
542  $ GO TO 20
543  ELSE
544  IF( .NOT.SELECT( k ) )
545  $ GO TO 20
546  END IF
547  END IF
548 *
549  ks = ks + 1
550 *
551  IF( wants ) THEN
552 *
553 * Compute the reciprocal condition number of the k-th
554 * eigenvalue.
555 *
556  IF( pair ) THEN
557 *
558 * Complex eigenvalue pair.
559 *
560  rnrm = dlapy2( dnrm2( n, vr( 1, ks ), 1 ),
561  $ dnrm2( n, vr( 1, ks+1 ), 1 ) )
562  lnrm = dlapy2( dnrm2( n, vl( 1, ks ), 1 ),
563  $ dnrm2( n, vl( 1, ks+1 ), 1 ) )
564  CALL dgemv( 'N', n, n, one, a, lda, vr( 1, ks ), 1, zero,
565  $ work, 1 )
566  tmprr = ddot( n, work, 1, vl( 1, ks ), 1 )
567  tmpri = ddot( n, work, 1, vl( 1, ks+1 ), 1 )
568  CALL dgemv( 'N', n, n, one, a, lda, vr( 1, ks+1 ), 1,
569  $ zero, work, 1 )
570  tmpii = ddot( n, work, 1, vl( 1, ks+1 ), 1 )
571  tmpir = ddot( n, work, 1, vl( 1, ks ), 1 )
572  uhav = tmprr + tmpii
573  uhavi = tmpir - tmpri
574  CALL dgemv( 'N', n, n, one, b, ldb, vr( 1, ks ), 1, zero,
575  $ work, 1 )
576  tmprr = ddot( n, work, 1, vl( 1, ks ), 1 )
577  tmpri = ddot( n, work, 1, vl( 1, ks+1 ), 1 )
578  CALL dgemv( 'N', n, n, one, b, ldb, vr( 1, ks+1 ), 1,
579  $ zero, work, 1 )
580  tmpii = ddot( n, work, 1, vl( 1, ks+1 ), 1 )
581  tmpir = ddot( n, work, 1, vl( 1, ks ), 1 )
582  uhbv = tmprr + tmpii
583  uhbvi = tmpir - tmpri
584  uhav = dlapy2( uhav, uhavi )
585  uhbv = dlapy2( uhbv, uhbvi )
586  cond = dlapy2( uhav, uhbv )
587  s( ks ) = cond / ( rnrm*lnrm )
588  s( ks+1 ) = s( ks )
589 *
590  ELSE
591 *
592 * Real eigenvalue.
593 *
594  rnrm = dnrm2( n, vr( 1, ks ), 1 )
595  lnrm = dnrm2( n, vl( 1, ks ), 1 )
596  CALL dgemv( 'N', n, n, one, a, lda, vr( 1, ks ), 1, zero,
597  $ work, 1 )
598  uhav = ddot( n, work, 1, vl( 1, ks ), 1 )
599  CALL dgemv( 'N', n, n, one, b, ldb, vr( 1, ks ), 1, zero,
600  $ work, 1 )
601  uhbv = ddot( n, work, 1, vl( 1, ks ), 1 )
602  cond = dlapy2( uhav, uhbv )
603  IF( cond.EQ.zero ) THEN
604  s( ks ) = -one
605  ELSE
606  s( ks ) = cond / ( rnrm*lnrm )
607  END IF
608  END IF
609  END IF
610 *
611  IF( wantdf ) THEN
612  IF( n.EQ.1 ) THEN
613  dif( ks ) = dlapy2( a( 1, 1 ), b( 1, 1 ) )
614  GO TO 20
615  END IF
616 *
617 * Estimate the reciprocal condition number of the k-th
618 * eigenvectors.
619  IF( pair ) THEN
620 *
621 * Copy the 2-by 2 pencil beginning at (A(k,k), B(k, k)).
622 * Compute the eigenvalue(s) at position K.
623 *
624  work( 1 ) = a( k, k )
625  work( 2 ) = a( k+1, k )
626  work( 3 ) = a( k, k+1 )
627  work( 4 ) = a( k+1, k+1 )
628  work( 5 ) = b( k, k )
629  work( 6 ) = b( k+1, k )
630  work( 7 ) = b( k, k+1 )
631  work( 8 ) = b( k+1, k+1 )
632  CALL dlag2( work, 2, work( 5 ), 2, smlnum*eps, beta,
633  $ dummy1( 1 ), alphar, dummy( 1 ), alphai )
634  alprqt = one
635  c1 = two*( alphar*alphar+alphai*alphai+beta*beta )
636  c2 = four*beta*beta*alphai*alphai
637  root1 = c1 + sqrt( c1*c1-4.0d0*c2 )
638  root2 = c2 / root1
639  root1 = root1 / two
640  cond = min( sqrt( root1 ), sqrt( root2 ) )
641  END IF
642 *
643 * Copy the matrix (A, B) to the array WORK and swap the
644 * diagonal block beginning at A(k,k) to the (1,1) position.
645 *
646  CALL dlacpy( 'Full', n, n, a, lda, work, n )
647  CALL dlacpy( 'Full', n, n, b, ldb, work( n*n+1 ), n )
648  ifst = k
649  ilst = 1
650 *
651  CALL dtgexc( .false., .false., n, work, n, work( n*n+1 ), n,
652  $ dummy, 1, dummy1, 1, ifst, ilst,
653  $ work( n*n*2+1 ), lwork-2*n*n, ierr )
654 *
655  IF( ierr.GT.0 ) THEN
656 *
657 * Ill-conditioned problem - swap rejected.
658 *
659  dif( ks ) = zero
660  ELSE
661 *
662 * Reordering successful, solve generalized Sylvester
663 * equation for R and L,
664 * A22 * R - L * A11 = A12
665 * B22 * R - L * B11 = B12,
666 * and compute estimate of Difl((A11,B11), (A22, B22)).
667 *
668  n1 = 1
669  IF( work( 2 ).NE.zero )
670  $ n1 = 2
671  n2 = n - n1
672  IF( n2.EQ.0 ) THEN
673  dif( ks ) = cond
674  ELSE
675  i = n*n + 1
676  iz = 2*n*n + 1
677  CALL dtgsyl( 'N', difdri, n2, n1, work( n*n1+n1+1 ),
678  $ n, work, n, work( n1+1 ), n,
679  $ work( n*n1+n1+i ), n, work( i ), n,
680  $ work( n1+i ), n, scale, dif( ks ),
681  $ work( iz+1 ), lwork-2*n*n, iwork, ierr )
682 *
683  IF( pair )
684  $ dif( ks ) = min( max( one, alprqt )*dif( ks ),
685  $ cond )
686  END IF
687  END IF
688  IF( pair )
689  $ dif( ks+1 ) = dif( ks )
690  END IF
691  IF( pair )
692  $ ks = ks + 1
693 *
694  20 CONTINUE
695  work( 1 ) = lwmin
696  RETURN
697 *
698 * End of DTGSNA
699 *
subroutine dlacpy(UPLO, M, N, A, LDA, B, LDB)
DLACPY copies all or part of one two-dimensional array to another.
Definition: dlacpy.f:105
double precision function dlamch(CMACH)
DLAMCH
Definition: dlamch.f:65
double precision function ddot(N, DX, INCX, DY, INCY)
DDOT
Definition: ddot.f:84
subroutine dgemv(TRANS, M, N, ALPHA, A, LDA, X, INCX, BETA, Y, INCY)
DGEMV
Definition: dgemv.f:158
double precision function dnrm2(N, X, INCX)
DNRM2
Definition: dnrm2.f:76
subroutine dlag2(A, LDA, B, LDB, SAFMIN, SCALE1, SCALE2, WR1, WR2, WI)
DLAG2 computes the eigenvalues of a 2-by-2 generalized eigenvalue problem, with scaling as necessary ...
Definition: dlag2.f:158
subroutine xerbla(SRNAME, INFO)
XERBLA
Definition: xerbla.f:62
logical function lsame(CA, CB)
LSAME
Definition: lsame.f:55
subroutine dtgsyl(TRANS, IJOB, M, N, A, LDA, B, LDB, C, LDC, D, LDD, E, LDE, F, LDF, SCALE, DIF, WORK, LWORK, IWORK, INFO)
DTGSYL
Definition: dtgsyl.f:301
subroutine dtgexc(WANTQ, WANTZ, N, A, LDA, B, LDB, Q, LDQ, Z, LDZ, IFST, ILST, WORK, LWORK, INFO)
DTGEXC
Definition: dtgexc.f:222
double precision function dlapy2(X, Y)
DLAPY2 returns sqrt(x2+y2).
Definition: dlapy2.f:65
Here is the call graph for this function:
Here is the caller graph for this function: