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

◆ dgeesx()

subroutine dgeesx ( character jobvs,
character sort,
external select,
character sense,
integer n,
double precision, dimension( lda, * ) a,
integer lda,
integer sdim,
double precision, dimension( * ) wr,
double precision, dimension( * ) wi,
double precision, dimension( ldvs, * ) vs,
integer ldvs,
double precision rconde,
double precision rcondv,
double precision, dimension( * ) work,
integer lwork,
integer, dimension( * ) iwork,
integer liwork,
logical, dimension( * ) bwork,
integer info )

DGEESX computes the eigenvalues, the Schur form, and, optionally, the matrix of Schur vectors for GE matrices

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

Purpose:
!>
!> DGEESX computes for an N-by-N real nonsymmetric matrix A, the
!> eigenvalues, the real Schur form T, and, optionally, the matrix of
!> Schur vectors Z.  This gives the Schur factorization A = Z*T*(Z**T).
!>
!> Optionally, it also orders the eigenvalues on the diagonal of the
!> real Schur form so that selected eigenvalues are at the top left;
!> computes a reciprocal condition number for the average of the
!> selected eigenvalues (RCONDE); and computes a reciprocal condition
!> number for the right invariant subspace corresponding to the
!> selected eigenvalues (RCONDV).  The leading columns of Z form an
!> orthonormal basis for this invariant subspace.
!>
!> For further explanation of the reciprocal condition numbers RCONDE
!> and RCONDV, see Section 4.10 of the LAPACK Users' Guide (where
!> these quantities are called s and sep respectively).
!>
!> A real matrix is in real Schur form if it is upper quasi-triangular
!> with 1-by-1 and 2-by-2 blocks. 2-by-2 blocks will be standardized in
!> the form
!>           [  a  b  ]
!>           [  c  a  ]
!>
!> where b*c < 0. The eigenvalues of such a block are a +- sqrt(bc).
!> 
Parameters
[in]JOBVS
!>          JOBVS is CHARACTER*1
!>          = 'N': Schur vectors are not computed;
!>          = 'V': Schur vectors are computed.
!> 
[in]SORT
!>          SORT is CHARACTER*1
!>          Specifies whether or not to order the eigenvalues on the
!>          diagonal of the Schur form.
!>          = 'N': Eigenvalues are not ordered;
!>          = 'S': Eigenvalues are ordered (see SELECT).
!> 
[in]SELECT
!>          SELECT is a LOGICAL FUNCTION of two DOUBLE PRECISION arguments
!>          SELECT must be declared EXTERNAL in the calling subroutine.
!>          If SORT = 'S', SELECT is used to select eigenvalues to sort
!>          to the top left of the Schur form.
!>          If SORT = 'N', SELECT is not referenced.
!>          An eigenvalue WR(j)+sqrt(-1)*WI(j) is selected if
!>          SELECT(WR(j),WI(j)) is true; i.e., if either one of a
!>          complex conjugate pair of eigenvalues is selected, then both
!>          are.  Note that a selected complex eigenvalue may no longer
!>          satisfy SELECT(WR(j),WI(j)) = .TRUE. after ordering, since
!>          ordering may change the value of complex eigenvalues
!>          (especially if the eigenvalue is ill-conditioned); in this
!>          case INFO may be set to N+3 (see INFO below).
!> 
[in]SENSE
!>          SENSE is CHARACTER*1
!>          Determines which reciprocal condition numbers are computed.
!>          = 'N': None are computed;
!>          = 'E': Computed for average of selected eigenvalues only;
!>          = 'V': Computed for selected right invariant subspace only;
!>          = 'B': Computed for both.
!>          If SENSE = 'E', 'V' or 'B', SORT must equal 'S'.
!> 
[in]N
!>          N is INTEGER
!>          The order of the matrix A. N >= 0.
!> 
[in,out]A
!>          A is DOUBLE PRECISION array, dimension (LDA, N)
!>          On entry, the N-by-N matrix A.
!>          On exit, A is overwritten by its real Schur form T.
!> 
[in]LDA
!>          LDA is INTEGER
!>          The leading dimension of the array A.  LDA >= max(1,N).
!> 
[out]SDIM
!>          SDIM is INTEGER
!>          If SORT = 'N', SDIM = 0.
!>          If SORT = 'S', SDIM = number of eigenvalues (after sorting)
!>                         for which SELECT is true. (Complex conjugate
!>                         pairs for which SELECT is true for either
!>                         eigenvalue count as 2.)
!> 
[out]WR
!>          WR is DOUBLE PRECISION array, dimension (N)
!> 
[out]WI
!>          WI is DOUBLE PRECISION array, dimension (N)
!>          WR and WI contain the real and imaginary parts, respectively,
!>          of the computed eigenvalues, in the same order that they
!>          appear on the diagonal of the output Schur form T.  Complex
!>          conjugate pairs of eigenvalues appear consecutively with the
!>          eigenvalue having the positive imaginary part first.
!> 
[out]VS
!>          VS is DOUBLE PRECISION array, dimension (LDVS,N)
!>          If JOBVS = 'V', VS contains the orthogonal matrix Z of Schur
!>          vectors.
!>          If JOBVS = 'N', VS is not referenced.
!> 
[in]LDVS
!>          LDVS is INTEGER
!>          The leading dimension of the array VS.  LDVS >= 1, and if
!>          JOBVS = 'V', LDVS >= N.
!> 
[out]RCONDE
!>          RCONDE is DOUBLE PRECISION
!>          If SENSE = 'E' or 'B', RCONDE contains the reciprocal
!>          condition number for the average of the selected eigenvalues.
!>          Not referenced if SENSE = 'N' or 'V'.
!> 
[out]RCONDV
!>          RCONDV is DOUBLE PRECISION
!>          If SENSE = 'V' or 'B', RCONDV contains the reciprocal
!>          condition number for the selected right invariant subspace.
!>          Not referenced if SENSE = 'N' or 'E'.
!> 
[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,3*N).
!>          Also, if SENSE = 'E' or 'V' or 'B',
!>          LWORK >= N+2*SDIM*(N-SDIM), where SDIM is the number of
!>          selected eigenvalues computed by this routine.  Note that
!>          N+2*SDIM*(N-SDIM) <= N+N*N/2. Note also that an error is only
!>          returned if LWORK < max(1,3*N), but if SENSE = 'E' or 'V' or
!>          'B' this may not be large enough.
!>          For good performance, LWORK must generally be larger.
!>
!>          If LWORK = -1, then a workspace query is assumed; the routine
!>          only calculates upper bounds on the optimal sizes of the
!>          arrays WORK and IWORK, returns these values as the first
!>          entries of the WORK and IWORK arrays, and no error messages
!>          related to LWORK or LIWORK are issued by XERBLA.
!> 
[out]IWORK
!>          IWORK is INTEGER array, dimension (MAX(1,LIWORK))
!>          On exit, if INFO = 0, IWORK(1) returns the optimal LIWORK.
!> 
[in]LIWORK
!>          LIWORK is INTEGER
!>          The dimension of the array IWORK.
!>          LIWORK >= 1; if SENSE = 'V' or 'B', LIWORK >= SDIM*(N-SDIM).
!>          Note that SDIM*(N-SDIM) <= N*N/4. Note also that an error is
!>          only returned if LIWORK < 1, but if SENSE = 'V' or 'B' this
!>          may not be large enough.
!>
!>          If LIWORK = -1, then a workspace query is assumed; the
!>          routine only calculates upper bounds on the optimal sizes of
!>          the arrays WORK and IWORK, returns these values as the first
!>          entries of the WORK and IWORK arrays, and no error messages
!>          related to LWORK or LIWORK are issued by XERBLA.
!> 
[out]BWORK
!>          BWORK is LOGICAL array, dimension (N)
!>          Not referenced if SORT = 'N'.
!> 
[out]INFO
!>          INFO is INTEGER
!>          = 0: successful exit
!>          < 0: if INFO = -i, the i-th argument had an illegal value.
!>          > 0: if INFO = i, and i is
!>             <= N: the QR algorithm failed to compute all the
!>                   eigenvalues; elements 1:ILO-1 and i+1:N of WR and WI
!>                   contain those eigenvalues which have converged; if
!>                   JOBVS = 'V', VS contains the transformation which
!>                   reduces A to its partially converged Schur form.
!>             = N+1: the eigenvalues could not be reordered because some
!>                   eigenvalues were too close to separate (the problem
!>                   is very ill-conditioned);
!>             = N+2: after reordering, roundoff changed values of some
!>                   complex eigenvalues so that leading eigenvalues in
!>                   the Schur form no longer satisfy SELECT=.TRUE.  This
!>                   could also be caused by underflow due to scaling.
!> 
Author
Univ. of Tennessee
Univ. of California Berkeley
Univ. of Colorado Denver
NAG Ltd.

Definition at line 276 of file dgeesx.f.

279*
280* -- LAPACK driver routine --
281* -- LAPACK is a software package provided by Univ. of Tennessee, --
282* -- Univ. of California Berkeley, Univ. of Colorado Denver and NAG Ltd..--
283*
284* .. Scalar Arguments ..
285 CHARACTER JOBVS, SENSE, SORT
286 INTEGER INFO, LDA, LDVS, LIWORK, LWORK, N, SDIM
287 DOUBLE PRECISION RCONDE, RCONDV
288* ..
289* .. Array Arguments ..
290 LOGICAL BWORK( * )
291 INTEGER IWORK( * )
292 DOUBLE PRECISION A( LDA, * ), VS( LDVS, * ), WI( * ), WORK( * ),
293 $ WR( * )
294* ..
295* .. Function Arguments ..
296 LOGICAL SELECT
297 EXTERNAL SELECT
298* ..
299*
300* =====================================================================
301*
302* .. Parameters ..
303 DOUBLE PRECISION ZERO, ONE
304 parameter( zero = 0.0d0, one = 1.0d0 )
305* ..
306* .. Local Scalars ..
307 LOGICAL CURSL, LASTSL, LQUERY, LST2SL, SCALEA, WANTSB,
308 $ WANTSE, WANTSN, WANTST, WANTSV, WANTVS
309 INTEGER HSWORK, I, I1, I2, IBAL, ICOND, IERR, IEVAL,
310 $ IHI, ILO, INXT, IP, ITAU, IWRK, LIWRK, LWRK,
311 $ MAXWRK, MINWRK
312 DOUBLE PRECISION ANRM, BIGNUM, CSCALE, EPS, SMLNUM
313* ..
314* .. Local Arrays ..
315 DOUBLE PRECISION DUM( 1 )
316* ..
317* .. External Subroutines ..
318 EXTERNAL dcopy, dgebak, dgebal, dgehrd, dhseqr,
319 $ dlacpy,
321* ..
322* .. External Functions ..
323 LOGICAL LSAME
324 INTEGER ILAENV
325 DOUBLE PRECISION DLAMCH, DLANGE
326 EXTERNAL lsame, ilaenv, dlamch, dlange
327* ..
328* .. Intrinsic Functions ..
329 INTRINSIC max, sqrt
330* ..
331* .. Executable Statements ..
332*
333* Test the input arguments
334*
335 info = 0
336 wantvs = lsame( jobvs, 'V' )
337 wantst = lsame( sort, 'S' )
338 wantsn = lsame( sense, 'N' )
339 wantse = lsame( sense, 'E' )
340 wantsv = lsame( sense, 'V' )
341 wantsb = lsame( sense, 'B' )
342 lquery = ( lwork.EQ.-1 .OR. liwork.EQ.-1 )
343*
344 IF( ( .NOT.wantvs ) .AND. ( .NOT.lsame( jobvs, 'N' ) ) ) THEN
345 info = -1
346 ELSE IF( ( .NOT.wantst ) .AND.
347 $ ( .NOT.lsame( sort, 'N' ) ) ) THEN
348 info = -2
349 ELSE IF( .NOT.( wantsn .OR. wantse .OR. wantsv .OR. wantsb ) .OR.
350 $ ( .NOT.wantst .AND. .NOT.wantsn ) ) THEN
351 info = -4
352 ELSE IF( n.LT.0 ) THEN
353 info = -5
354 ELSE IF( lda.LT.max( 1, n ) ) THEN
355 info = -7
356 ELSE IF( ldvs.LT.1 .OR. ( wantvs .AND. ldvs.LT.n ) ) THEN
357 info = -12
358 END IF
359*
360* Compute workspace
361* (Note: Comments in the code beginning "RWorkspace:" describe the
362* minimal amount of real workspace needed at that point in the
363* code, as well as the preferred amount for good performance.
364* IWorkspace refers to integer workspace.
365* NB refers to the optimal block size for the immediately
366* following subroutine, as returned by ILAENV.
367* HSWORK refers to the workspace preferred by DHSEQR, as
368* calculated below. HSWORK is computed assuming ILO=1 and IHI=N,
369* the worst case.
370* If SENSE = 'E', 'V' or 'B', then the amount of workspace needed
371* depends on SDIM, which is computed by the routine DTRSEN later
372* in the code.)
373*
374 IF( info.EQ.0 ) THEN
375 liwrk = 1
376 IF( n.EQ.0 ) THEN
377 minwrk = 1
378 lwrk = 1
379 ELSE
380 maxwrk = 2*n + n*ilaenv( 1, 'DGEHRD', ' ', n, 1, n, 0 )
381 minwrk = 3*n
382*
383 CALL dhseqr( 'S', jobvs, n, 1, n, a, lda, wr, wi, vs,
384 $ ldvs,
385 $ work, -1, ieval )
386 hswork = int( work( 1 ) )
387*
388 IF( .NOT.wantvs ) THEN
389 maxwrk = max( maxwrk, n + hswork )
390 ELSE
391 maxwrk = max( maxwrk, 2*n + ( n - 1 )*ilaenv( 1,
392 $ 'DORGHR', ' ', n, 1, n, -1 ) )
393 maxwrk = max( maxwrk, n + hswork )
394 END IF
395 lwrk = maxwrk
396 IF( .NOT.wantsn )
397 $ lwrk = max( lwrk, n + ( n*n )/2 )
398 IF( wantsv .OR. wantsb )
399 $ liwrk = ( n*n )/4
400 END IF
401 iwork( 1 ) = liwrk
402 work( 1 ) = lwrk
403*
404 IF( lwork.LT.minwrk .AND. .NOT.lquery ) THEN
405 info = -16
406 ELSE IF( liwork.LT.1 .AND. .NOT.lquery ) THEN
407 info = -18
408 END IF
409 END IF
410*
411 IF( info.NE.0 ) THEN
412 CALL xerbla( 'DGEESX', -info )
413 RETURN
414 ELSE IF( lquery ) THEN
415 RETURN
416 END IF
417*
418* Quick return if possible
419*
420 IF( n.EQ.0 ) THEN
421 sdim = 0
422 RETURN
423 END IF
424*
425* Get machine constants
426*
427 eps = dlamch( 'P' )
428 smlnum = dlamch( 'S' )
429 bignum = one / smlnum
430 smlnum = sqrt( smlnum ) / eps
431 bignum = one / smlnum
432*
433* Scale A if max element outside range [SMLNUM,BIGNUM]
434*
435 anrm = dlange( 'M', n, n, a, lda, dum )
436 scalea = .false.
437 IF( anrm.GT.zero .AND. anrm.LT.smlnum ) THEN
438 scalea = .true.
439 cscale = smlnum
440 ELSE IF( anrm.GT.bignum ) THEN
441 scalea = .true.
442 cscale = bignum
443 END IF
444 IF( scalea )
445 $ CALL dlascl( 'G', 0, 0, anrm, cscale, n, n, a, lda, ierr )
446*
447* Permute the matrix to make it more nearly triangular
448* (RWorkspace: need N)
449*
450 ibal = 1
451 CALL dgebal( 'P', n, a, lda, ilo, ihi, work( ibal ), ierr )
452*
453* Reduce to upper Hessenberg form
454* (RWorkspace: need 3*N, prefer 2*N+N*NB)
455*
456 itau = n + ibal
457 iwrk = n + itau
458 CALL dgehrd( n, ilo, ihi, a, lda, work( itau ), work( iwrk ),
459 $ lwork-iwrk+1, ierr )
460*
461 IF( wantvs ) THEN
462*
463* Copy Householder vectors to VS
464*
465 CALL dlacpy( 'L', n, n, a, lda, vs, ldvs )
466*
467* Generate orthogonal matrix in VS
468* (RWorkspace: need 3*N-1, prefer 2*N+(N-1)*NB)
469*
470 CALL dorghr( n, ilo, ihi, vs, ldvs, work( itau ),
471 $ work( iwrk ),
472 $ lwork-iwrk+1, ierr )
473 END IF
474*
475 sdim = 0
476*
477* Perform QR iteration, accumulating Schur vectors in VS if desired
478* (RWorkspace: need N+1, prefer N+HSWORK (see comments) )
479*
480 iwrk = itau
481 CALL dhseqr( 'S', jobvs, n, ilo, ihi, a, lda, wr, wi, vs, ldvs,
482 $ work( iwrk ), lwork-iwrk+1, ieval )
483 IF( ieval.GT.0 )
484 $ info = ieval
485*
486* Sort eigenvalues if desired
487*
488 IF( wantst .AND. info.EQ.0 ) THEN
489 IF( scalea ) THEN
490 CALL dlascl( 'G', 0, 0, cscale, anrm, n, 1, wr, n, ierr )
491 CALL dlascl( 'G', 0, 0, cscale, anrm, n, 1, wi, n, ierr )
492 END IF
493 DO 10 i = 1, n
494 bwork( i ) = SELECT( wr( i ), wi( i ) )
495 10 CONTINUE
496*
497* Reorder eigenvalues, transform Schur vectors, and compute
498* reciprocal condition numbers
499* (RWorkspace: if SENSE is not 'N', need N+2*SDIM*(N-SDIM)
500* otherwise, need N )
501* (IWorkspace: if SENSE is 'V' or 'B', need SDIM*(N-SDIM)
502* otherwise, need 0 )
503*
504 CALL dtrsen( sense, jobvs, bwork, n, a, lda, vs, ldvs, wr,
505 $ wi,
506 $ sdim, rconde, rcondv, work( iwrk ), lwork-iwrk+1,
507 $ iwork, liwork, icond )
508 IF( .NOT.wantsn )
509 $ maxwrk = max( maxwrk, n+2*sdim*( n-sdim ) )
510 IF( icond.EQ.-15 ) THEN
511*
512* Not enough real workspace
513*
514 info = -16
515 ELSE IF( icond.EQ.-17 ) THEN
516*
517* Not enough integer workspace
518*
519 info = -18
520 ELSE IF( icond.GT.0 ) THEN
521*
522* DTRSEN failed to reorder or to restore standard Schur form
523*
524 info = icond + n
525 END IF
526 END IF
527*
528 IF( wantvs ) THEN
529*
530* Undo balancing
531* (RWorkspace: need N)
532*
533 CALL dgebak( 'P', 'R', n, ilo, ihi, work( ibal ), n, vs,
534 $ ldvs,
535 $ ierr )
536 END IF
537*
538 IF( scalea ) THEN
539*
540* Undo scaling for the Schur form of A
541*
542 CALL dlascl( 'H', 0, 0, cscale, anrm, n, n, a, lda, ierr )
543 CALL dcopy( n, a, lda+1, wr, 1 )
544 IF( ( wantsv .OR. wantsb ) .AND. info.EQ.0 ) THEN
545 dum( 1 ) = rcondv
546 CALL dlascl( 'G', 0, 0, cscale, anrm, 1, 1, dum, 1,
547 $ ierr )
548 rcondv = dum( 1 )
549 END IF
550 IF( cscale.EQ.smlnum ) THEN
551*
552* If scaling back towards underflow, adjust WI if an
553* offdiagonal element of a 2-by-2 block in the Schur form
554* underflows.
555*
556 IF( ieval.GT.0 ) THEN
557 i1 = ieval + 1
558 i2 = ihi - 1
559 CALL dlascl( 'G', 0, 0, cscale, anrm, ilo-1, 1, wi, n,
560 $ ierr )
561 ELSE IF( wantst ) THEN
562 i1 = 1
563 i2 = n - 1
564 ELSE
565 i1 = ilo
566 i2 = ihi - 1
567 END IF
568 inxt = i1 - 1
569 DO 20 i = i1, i2
570 IF( i.LT.inxt )
571 $ GO TO 20
572 IF( wi( i ).EQ.zero ) THEN
573 inxt = i + 1
574 ELSE
575 IF( a( i+1, i ).EQ.zero ) THEN
576 wi( i ) = zero
577 wi( i+1 ) = zero
578 ELSE IF( a( i+1, i ).NE.zero .AND. a( i, i+1 ).EQ.
579 $ zero ) THEN
580 wi( i ) = zero
581 wi( i+1 ) = zero
582 IF( i.GT.1 )
583 $ CALL dswap( i-1, a( 1, i ), 1, a( 1, i+1 ),
584 $ 1 )
585 IF( n.GT.i+1 )
586 $ CALL dswap( n-i-1, a( i, i+2 ), lda,
587 $ a( i+1, i+2 ), lda )
588 IF( wantvs ) THEN
589 CALL dswap( n, vs( 1, i ), 1, vs( 1, i+1 ),
590 $ 1 )
591 END IF
592 a( i, i+1 ) = a( i+1, i )
593 a( i+1, i ) = zero
594 END IF
595 inxt = i + 2
596 END IF
597 20 CONTINUE
598 END IF
599 CALL dlascl( 'G', 0, 0, cscale, anrm, n-ieval, 1,
600 $ wi( ieval+1 ), max( n-ieval, 1 ), ierr )
601 END IF
602*
603 IF( wantst .AND. info.EQ.0 ) THEN
604*
605* Check if reordering successful
606*
607 lastsl = .true.
608 lst2sl = .true.
609 sdim = 0
610 ip = 0
611 DO 30 i = 1, n
612 cursl = SELECT( wr( i ), wi( i ) )
613 IF( wi( i ).EQ.zero ) THEN
614 IF( cursl )
615 $ sdim = sdim + 1
616 ip = 0
617 IF( cursl .AND. .NOT.lastsl )
618 $ info = n + 2
619 ELSE
620 IF( ip.EQ.1 ) THEN
621*
622* Last eigenvalue of conjugate pair
623*
624 cursl = cursl .OR. lastsl
625 lastsl = cursl
626 IF( cursl )
627 $ sdim = sdim + 2
628 ip = -1
629 IF( cursl .AND. .NOT.lst2sl )
630 $ info = n + 2
631 ELSE
632*
633* First eigenvalue of conjugate pair
634*
635 ip = 1
636 END IF
637 END IF
638 lst2sl = lastsl
639 lastsl = cursl
640 30 CONTINUE
641 END IF
642*
643 work( 1 ) = maxwrk
644 IF( wantsv .OR. wantsb ) THEN
645 iwork( 1 ) = max( 1, sdim*( n-sdim ) )
646 ELSE
647 iwork( 1 ) = 1
648 END IF
649*
650 RETURN
651*
652* End of DGEESX
653*
subroutine xerbla(srname, info)
Definition cblat2.f:3285
subroutine dcopy(n, dx, incx, dy, incy)
DCOPY
Definition dcopy.f:82
subroutine dgebak(job, side, n, ilo, ihi, scale, m, v, ldv, info)
DGEBAK
Definition dgebak.f:128
subroutine dgebal(job, n, a, lda, ilo, ihi, scale, info)
DGEBAL
Definition dgebal.f:161
subroutine dgehrd(n, ilo, ihi, a, lda, tau, work, lwork, info)
DGEHRD
Definition dgehrd.f:166
subroutine dhseqr(job, compz, n, ilo, ihi, h, ldh, wr, wi, z, ldz, work, lwork, info)
DHSEQR
Definition dhseqr.f:314
integer function ilaenv(ispec, name, opts, n1, n2, n3, n4)
ILAENV
Definition ilaenv.f:160
subroutine dlacpy(uplo, m, n, a, lda, b, ldb)
DLACPY copies all or part of one two-dimensional array to another.
Definition dlacpy.f:101
double precision function dlamch(cmach)
DLAMCH
Definition dlamch.f:69
double precision function dlange(norm, m, n, a, lda, work)
DLANGE returns the value of the 1-norm, Frobenius norm, infinity-norm, or the largest absolute value ...
Definition dlange.f:112
subroutine dlascl(type, kl, ku, cfrom, cto, m, n, a, lda, info)
DLASCL multiplies a general rectangular matrix by a real scalar defined as cto/cfrom.
Definition dlascl.f:142
logical function lsame(ca, cb)
LSAME
Definition lsame.f:48
subroutine dswap(n, dx, incx, dy, incy)
DSWAP
Definition dswap.f:82
subroutine dtrsen(job, compq, select, n, t, ldt, q, ldq, wr, wi, m, s, sep, work, lwork, iwork, liwork, info)
DTRSEN
Definition dtrsen.f:312
subroutine dorghr(n, ilo, ihi, a, lda, tau, work, lwork, info)
DORGHR
Definition dorghr.f:125
Here is the call graph for this function:
Here is the caller graph for this function: