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

◆ slaqr3()

subroutine slaqr3 ( logical wantt,
logical wantz,
integer n,
integer ktop,
integer kbot,
integer nw,
real, dimension( ldh, * ) h,
integer ldh,
integer iloz,
integer ihiz,
real, dimension( ldz, * ) z,
integer ldz,
integer ns,
integer nd,
real, dimension( * ) sr,
real, dimension( * ) si,
real, dimension( ldv, * ) v,
integer ldv,
integer nh,
real, dimension( ldt, * ) t,
integer ldt,
integer nv,
real, dimension( ldwv, * ) wv,
integer ldwv,
real, dimension( * ) work,
integer lwork )

SLAQR3 performs the orthogonal similarity transformation of a Hessenberg matrix to detect and deflate fully converged eigenvalues from a trailing principal submatrix (aggressive early deflation).

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

Purpose:
!>
!>    Aggressive early deflation:
!>
!>    SLAQR3 accepts as input an upper Hessenberg matrix
!>    H and performs an orthogonal similarity transformation
!>    designed to detect and deflate fully converged eigenvalues from
!>    a trailing principal submatrix.  On output H has been over-
!>    written by a new Hessenberg matrix that is a perturbation of
!>    an orthogonal similarity transformation of H.  It is to be
!>    hoped that the final version of H has many zero subdiagonal
!>    entries.
!>
Parameters
[in]WANTT
!>          WANTT is LOGICAL
!>          If .TRUE., then the Hessenberg matrix H is fully updated
!>          so that the quasi-triangular Schur factor may be
!>          computed (in cooperation with the calling subroutine).
!>          If .FALSE., then only enough of H is updated to preserve
!>          the eigenvalues.
!>
[in]WANTZ
!>          WANTZ is LOGICAL
!>          If .TRUE., then the orthogonal matrix Z is updated so
!>          so that the orthogonal Schur factor may be computed
!>          (in cooperation with the calling subroutine).
!>          If .FALSE., then Z is not referenced.
!>
[in]N
!>          N is INTEGER
!>          The order of the matrix H and (if WANTZ is .TRUE.) the
!>          order of the orthogonal matrix Z.
!>
[in]KTOP
!>          KTOP is INTEGER
!>          It is assumed that either KTOP = 1 or H(KTOP,KTOP-1)=0.
!>          KBOT and KTOP together determine an isolated block
!>          along the diagonal of the Hessenberg matrix.
!>
[in]KBOT
!>          KBOT is INTEGER
!>          It is assumed without a check that either
!>          KBOT = N or H(KBOT+1,KBOT)=0.  KBOT and KTOP together
!>          determine an isolated block along the diagonal of the
!>          Hessenberg matrix.
!>
[in]NW
!>          NW is INTEGER
!>          Deflation window size.  1 <= NW <= (KBOT-KTOP+1).
!>
[in,out]H
!>          H is REAL array, dimension (LDH,N)
!>          On input the initial N-by-N section of H stores the
!>          Hessenberg matrix undergoing aggressive early deflation.
!>          On output H has been transformed by an orthogonal
!>          similarity transformation, perturbed, and the returned
!>          to Hessenberg form that (it is to be hoped) has some
!>          zero subdiagonal entries.
!>
[in]LDH
!>          LDH is INTEGER
!>          Leading dimension of H just as declared in the calling
!>          subroutine.  N <= LDH
!>
[in]ILOZ
!>          ILOZ is INTEGER
!>
[in]IHIZ
!>          IHIZ is INTEGER
!>          Specify the rows of Z to which transformations must be
!>          applied if WANTZ is .TRUE.. 1 <= ILOZ <= IHIZ <= N.
!>
[in,out]Z
!>          Z is REAL array, dimension (LDZ,N)
!>          IF WANTZ is .TRUE., then on output, the orthogonal
!>          similarity transformation mentioned above has been
!>          accumulated into Z(ILOZ:IHIZ,ILOZ:IHIZ) from the right.
!>          If WANTZ is .FALSE., then Z is unreferenced.
!>
[in]LDZ
!>          LDZ is INTEGER
!>          The leading dimension of Z just as declared in the
!>          calling subroutine.  1 <= LDZ.
!>
[out]NS
!>          NS is INTEGER
!>          The number of unconverged (ie approximate) eigenvalues
!>          returned in SR and SI that may be used as shifts by the
!>          calling subroutine.
!>
[out]ND
!>          ND is INTEGER
!>          The number of converged eigenvalues uncovered by this
!>          subroutine.
!>
[out]SR
!>          SR is REAL array, dimension (KBOT)
!>
[out]SI
!>          SI is REAL array, dimension (KBOT)
!>          On output, the real and imaginary parts of approximate
!>          eigenvalues that may be used for shifts are stored in
!>          SR(KBOT-ND-NS+1) through SR(KBOT-ND) and
!>          SI(KBOT-ND-NS+1) through SI(KBOT-ND), respectively.
!>          The real and imaginary parts of converged eigenvalues
!>          are stored in SR(KBOT-ND+1) through SR(KBOT) and
!>          SI(KBOT-ND+1) through SI(KBOT), respectively.
!>
[out]V
!>          V is REAL array, dimension (LDV,NW)
!>          An NW-by-NW work array.
!>
[in]LDV
!>          LDV is INTEGER
!>          The leading dimension of V just as declared in the
!>          calling subroutine.  NW <= LDV
!>
[in]NH
!>          NH is INTEGER
!>          The number of columns of T.  NH >= NW.
!>
[out]T
!>          T is REAL array, dimension (LDT,NW)
!>
[in]LDT
!>          LDT is INTEGER
!>          The leading dimension of T just as declared in the
!>          calling subroutine.  NW <= LDT
!>
[in]NV
!>          NV is INTEGER
!>          The number of rows of work array WV available for
!>          workspace.  NV >= NW.
!>
[out]WV
!>          WV is REAL array, dimension (LDWV,NW)
!>
[in]LDWV
!>          LDWV is INTEGER
!>          The leading dimension of W just as declared in the
!>          calling subroutine.  NW <= LDV
!>
[out]WORK
!>          WORK is REAL array, dimension (LWORK)
!>          On exit, WORK(1) is set to an estimate of the optimal value
!>          of LWORK for the given values of N, NW, KTOP and KBOT.
!>
[in]LWORK
!>          LWORK is INTEGER
!>          The dimension of the work array WORK.  LWORK = 2*NW
!>          suffices, but greater efficiency may result from larger
!>          values of LWORK.
!>
!>          If LWORK = -1, then a workspace query is assumed; SLAQR3
!>          only estimates the optimal workspace size for the given
!>          values of N, NW, KTOP and KBOT.  The estimate is returned
!>          in WORK(1).  No error message related to LWORK is issued
!>          by XERBLA.  Neither H nor Z are accessed.
!>
Author
Univ. of Tennessee
Univ. of California Berkeley
Univ. of Colorado Denver
NAG Ltd.
Contributors:
Karen Braman and Ralph Byers, Department of Mathematics, University of Kansas, USA

Definition at line 270 of file slaqr3.f.

274*
275* -- LAPACK auxiliary routine --
276* -- LAPACK is a software package provided by Univ. of Tennessee, --
277* -- Univ. of California Berkeley, Univ. of Colorado Denver and NAG Ltd..--
278*
279* .. Scalar Arguments ..
280 INTEGER IHIZ, ILOZ, KBOT, KTOP, LDH, LDT, LDV, LDWV,
281 $ LDZ, LWORK, N, ND, NH, NS, NV, NW
282 LOGICAL WANTT, WANTZ
283* ..
284* .. Array Arguments ..
285 REAL H( LDH, * ), SI( * ), SR( * ), T( LDT, * ),
286 $ V( LDV, * ), WORK( * ), WV( LDWV, * ),
287 $ Z( LDZ, * )
288* ..
289*
290* ================================================================
291* .. Parameters ..
292 REAL ZERO, ONE
293 parameter( zero = 0.0e0, one = 1.0e0 )
294* ..
295* .. Local Scalars ..
296 REAL AA, BB, CC, CS, DD, EVI, EVK, FOO, S,
297 $ SAFMAX, SAFMIN, SMLNUM, SN, TAU, ULP
298 INTEGER I, IFST, ILST, INFO, INFQR, J, JW, K, KCOL,
299 $ KEND, KLN, KROW, KWTOP, LTOP, LWK1, LWK2, LWK3,
300 $ LWKOPT, NMIN
301 LOGICAL BULGE, SORTED
302* ..
303* .. External Functions ..
304 REAL SLAMCH, SROUNDUP_LWORK
305 INTEGER ILAENV
306 EXTERNAL slamch, sroundup_lwork, ilaenv
307* ..
308* .. External Subroutines ..
309 EXTERNAL scopy, sgehrd, sgemm, slacpy, slahqr,
310 $ slanv2,
311 $ slaqr4, slarf1f, slarfg, slaset, sormhr,
312 $ strexc
313* ..
314* .. Intrinsic Functions ..
315 INTRINSIC abs, int, max, min, real, sqrt
316* ..
317* .. Executable Statements ..
318*
319* ==== Estimate optimal workspace. ====
320*
321 jw = min( nw, kbot-ktop+1 )
322 IF( jw.LE.2 ) THEN
323 lwkopt = 1
324 ELSE
325*
326* ==== Workspace query call to SGEHRD ====
327*
328 CALL sgehrd( jw, 1, jw-1, t, ldt, work, work, -1, info )
329 lwk1 = int( work( 1 ) )
330*
331* ==== Workspace query call to SORMHR ====
332*
333 CALL sormhr( 'R', 'N', jw, jw, 1, jw-1, t, ldt, work, v,
334 $ ldv,
335 $ work, -1, info )
336 lwk2 = int( work( 1 ) )
337*
338* ==== Workspace query call to SLAQR4 ====
339*
340 CALL slaqr4( .true., .true., jw, 1, jw, t, ldt, sr, si, 1,
341 $ jw,
342 $ v, ldv, work, -1, infqr )
343 lwk3 = int( work( 1 ) )
344*
345* ==== Optimal workspace ====
346*
347 lwkopt = max( jw+max( lwk1, lwk2 ), lwk3 )
348 END IF
349*
350* ==== Quick return in case of workspace query. ====
351*
352 IF( lwork.EQ.-1 ) THEN
353 work( 1 ) = sroundup_lwork( lwkopt )
354 RETURN
355 END IF
356*
357* ==== Nothing to do ...
358* ... for an empty active block ... ====
359 ns = 0
360 nd = 0
361 work( 1 ) = one
362 IF( ktop.GT.kbot )
363 $ RETURN
364* ... nor for an empty deflation window. ====
365 IF( nw.LT.1 )
366 $ RETURN
367*
368* ==== Machine constants ====
369*
370 safmin = slamch( 'SAFE MINIMUM' )
371 safmax = one / safmin
372 ulp = slamch( 'PRECISION' )
373 smlnum = safmin*( real( n ) / ulp )
374*
375* ==== Setup deflation window ====
376*
377 jw = min( nw, kbot-ktop+1 )
378 kwtop = kbot - jw + 1
379 IF( kwtop.EQ.ktop ) THEN
380 s = zero
381 ELSE
382 s = h( kwtop, kwtop-1 )
383 END IF
384*
385 IF( kbot.EQ.kwtop ) THEN
386*
387* ==== 1-by-1 deflation window: not much to do ====
388*
389 sr( kwtop ) = h( kwtop, kwtop )
390 si( kwtop ) = zero
391 ns = 1
392 nd = 0
393 IF( abs( s ).LE.max( smlnum, ulp*abs( h( kwtop, kwtop ) ) ) )
394 $ THEN
395 ns = 0
396 nd = 1
397 IF( kwtop.GT.ktop )
398 $ h( kwtop, kwtop-1 ) = zero
399 END IF
400 work( 1 ) = one
401 RETURN
402 END IF
403*
404* ==== Convert to spike-triangular form. (In case of a
405* . rare QR failure, this routine continues to do
406* . aggressive early deflation using that part of
407* . the deflation window that converged using INFQR
408* . here and there to keep track.) ====
409*
410 CALL slacpy( 'U', jw, jw, h( kwtop, kwtop ), ldh, t, ldt )
411 CALL scopy( jw-1, h( kwtop+1, kwtop ), ldh+1, t( 2, 1 ),
412 $ ldt+1 )
413*
414 CALL slaset( 'A', jw, jw, zero, one, v, ldv )
415 nmin = ilaenv( 12, 'SLAQR3', 'SV', jw, 1, jw, lwork )
416 IF( jw.GT.nmin ) THEN
417 CALL slaqr4( .true., .true., jw, 1, jw, t, ldt, sr( kwtop ),
418 $ si( kwtop ), 1, jw, v, ldv, work, lwork, infqr )
419 ELSE
420 CALL slahqr( .true., .true., jw, 1, jw, t, ldt, sr( kwtop ),
421 $ si( kwtop ), 1, jw, v, ldv, infqr )
422 END IF
423*
424* ==== STREXC needs a clean margin near the diagonal ====
425*
426 DO 10 j = 1, jw - 3
427 t( j+2, j ) = zero
428 t( j+3, j ) = zero
429 10 CONTINUE
430 IF( jw.GT.2 )
431 $ t( jw, jw-2 ) = zero
432*
433* ==== Deflation detection loop ====
434*
435 ns = jw
436 ilst = infqr + 1
437 20 CONTINUE
438 IF( ilst.LE.ns ) THEN
439 IF( ns.EQ.1 ) THEN
440 bulge = .false.
441 ELSE
442 bulge = t( ns, ns-1 ).NE.zero
443 END IF
444*
445* ==== Small spike tip test for deflation ====
446*
447 IF( .NOT. bulge ) THEN
448*
449* ==== Real eigenvalue ====
450*
451 foo = abs( t( ns, ns ) )
452 IF( foo.EQ.zero )
453 $ foo = abs( s )
454 IF( abs( s*v( 1, ns ) ).LE.max( smlnum, ulp*foo ) ) THEN
455*
456* ==== Deflatable ====
457*
458 ns = ns - 1
459 ELSE
460*
461* ==== Undeflatable. Move it up out of the way.
462* . (STREXC can not fail in this case.) ====
463*
464 ifst = ns
465 CALL strexc( 'V', jw, t, ldt, v, ldv, ifst, ilst,
466 $ work,
467 $ info )
468 ilst = ilst + 1
469 END IF
470 ELSE
471*
472* ==== Complex conjugate pair ====
473*
474 foo = abs( t( ns, ns ) ) + sqrt( abs( t( ns, ns-1 ) ) )*
475 $ sqrt( abs( t( ns-1, ns ) ) )
476 IF( foo.EQ.zero )
477 $ foo = abs( s )
478 IF( max( abs( s*v( 1, ns ) ), abs( s*v( 1, ns-1 ) ) ).LE.
479 $ max( smlnum, ulp*foo ) ) THEN
480*
481* ==== Deflatable ====
482*
483 ns = ns - 2
484 ELSE
485*
486* ==== Undeflatable. Move them up out of the way.
487* . Fortunately, STREXC does the right thing with
488* . ILST in case of a rare exchange failure. ====
489*
490 ifst = ns
491 CALL strexc( 'V', jw, t, ldt, v, ldv, ifst, ilst,
492 $ work,
493 $ info )
494 ilst = ilst + 2
495 END IF
496 END IF
497*
498* ==== End deflation detection loop ====
499*
500 GO TO 20
501 END IF
502*
503* ==== Return to Hessenberg form ====
504*
505 IF( ns.EQ.0 )
506 $ s = zero
507*
508 IF( ns.LT.jw ) THEN
509*
510* ==== sorting diagonal blocks of T improves accuracy for
511* . graded matrices. Bubble sort deals well with
512* . exchange failures. ====
513*
514 sorted = .false.
515 i = ns + 1
516 30 CONTINUE
517 IF( sorted )
518 $ GO TO 50
519 sorted = .true.
520*
521 kend = i - 1
522 i = infqr + 1
523 IF( i.EQ.ns ) THEN
524 k = i + 1
525 ELSE IF( t( i+1, i ).EQ.zero ) THEN
526 k = i + 1
527 ELSE
528 k = i + 2
529 END IF
530 40 CONTINUE
531 IF( k.LE.kend ) THEN
532 IF( k.EQ.i+1 ) THEN
533 evi = abs( t( i, i ) )
534 ELSE
535 evi = abs( t( i, i ) ) + sqrt( abs( t( i+1, i ) ) )*
536 $ sqrt( abs( t( i, i+1 ) ) )
537 END IF
538*
539 IF( k.EQ.kend ) THEN
540 evk = abs( t( k, k ) )
541 ELSE IF( t( k+1, k ).EQ.zero ) THEN
542 evk = abs( t( k, k ) )
543 ELSE
544 evk = abs( t( k, k ) ) + sqrt( abs( t( k+1, k ) ) )*
545 $ sqrt( abs( t( k, k+1 ) ) )
546 END IF
547*
548 IF( evi.GE.evk ) THEN
549 i = k
550 ELSE
551 sorted = .false.
552 ifst = i
553 ilst = k
554 CALL strexc( 'V', jw, t, ldt, v, ldv, ifst, ilst,
555 $ work,
556 $ info )
557 IF( info.EQ.0 ) THEN
558 i = ilst
559 ELSE
560 i = k
561 END IF
562 END IF
563 IF( i.EQ.kend ) THEN
564 k = i + 1
565 ELSE IF( t( i+1, i ).EQ.zero ) THEN
566 k = i + 1
567 ELSE
568 k = i + 2
569 END IF
570 GO TO 40
571 END IF
572 GO TO 30
573 50 CONTINUE
574 END IF
575*
576* ==== Restore shift/eigenvalue array from T ====
577*
578 i = jw
579 60 CONTINUE
580 IF( i.GE.infqr+1 ) THEN
581 IF( i.EQ.infqr+1 ) THEN
582 sr( kwtop+i-1 ) = t( i, i )
583 si( kwtop+i-1 ) = zero
584 i = i - 1
585 ELSE IF( t( i, i-1 ).EQ.zero ) THEN
586 sr( kwtop+i-1 ) = t( i, i )
587 si( kwtop+i-1 ) = zero
588 i = i - 1
589 ELSE
590 aa = t( i-1, i-1 )
591 cc = t( i, i-1 )
592 bb = t( i-1, i )
593 dd = t( i, i )
594 CALL slanv2( aa, bb, cc, dd, sr( kwtop+i-2 ),
595 $ si( kwtop+i-2 ), sr( kwtop+i-1 ),
596 $ si( kwtop+i-1 ), cs, sn )
597 i = i - 2
598 END IF
599 GO TO 60
600 END IF
601*
602 IF( ns.LT.jw .OR. s.EQ.zero ) THEN
603 IF( ns.GT.1 .AND. s.NE.zero ) THEN
604*
605* ==== Reflect spike back into lower triangle ====
606*
607 CALL scopy( ns, v, ldv, work, 1 )
608 CALL slarfg( ns, work( 1 ), work( 2 ), 1, tau )
609*
610 CALL slaset( 'L', jw-2, jw-2, zero, zero, t( 3, 1 ),
611 $ ldt )
612*
613 CALL slarf1f( 'L', ns, jw, work, 1, tau, t, ldt,
614 $ work( jw+1 ) )
615 CALL slarf1f( 'R', ns, ns, work, 1, tau, t, ldt,
616 $ work( jw+1 ) )
617 CALL slarf1f( 'R', jw, ns, work, 1, tau, v, ldv,
618 $ work( jw+1 ) )
619*
620 CALL sgehrd( jw, 1, ns, t, ldt, work, work( jw+1 ),
621 $ lwork-jw, info )
622 END IF
623*
624* ==== Copy updated reduced window into place ====
625*
626 IF( kwtop.GT.1 )
627 $ h( kwtop, kwtop-1 ) = s*v( 1, 1 )
628 CALL slacpy( 'U', jw, jw, t, ldt, h( kwtop, kwtop ), ldh )
629 CALL scopy( jw-1, t( 2, 1 ), ldt+1, h( kwtop+1, kwtop ),
630 $ ldh+1 )
631*
632* ==== Accumulate orthogonal matrix in order update
633* . H and Z, if requested. ====
634*
635 IF( ns.GT.1 .AND. s.NE.zero )
636 $ CALL sormhr( 'R', 'N', jw, ns, 1, ns, t, ldt, work, v,
637 $ ldv,
638 $ work( jw+1 ), lwork-jw, info )
639*
640* ==== Update vertical slab in H ====
641*
642 IF( wantt ) THEN
643 ltop = 1
644 ELSE
645 ltop = ktop
646 END IF
647 DO 70 krow = ltop, kwtop - 1, nv
648 kln = min( nv, kwtop-krow )
649 CALL sgemm( 'N', 'N', kln, jw, jw, one, h( krow, kwtop ),
650 $ ldh, v, ldv, zero, wv, ldwv )
651 CALL slacpy( 'A', kln, jw, wv, ldwv, h( krow, kwtop ),
652 $ ldh )
653 70 CONTINUE
654*
655* ==== Update horizontal slab in H ====
656*
657 IF( wantt ) THEN
658 DO 80 kcol = kbot + 1, n, nh
659 kln = min( nh, n-kcol+1 )
660 CALL sgemm( 'C', 'N', jw, kln, jw, one, v, ldv,
661 $ h( kwtop, kcol ), ldh, zero, t, ldt )
662 CALL slacpy( 'A', jw, kln, t, ldt, h( kwtop, kcol ),
663 $ ldh )
664 80 CONTINUE
665 END IF
666*
667* ==== Update vertical slab in Z ====
668*
669 IF( wantz ) THEN
670 DO 90 krow = iloz, ihiz, nv
671 kln = min( nv, ihiz-krow+1 )
672 CALL sgemm( 'N', 'N', kln, jw, jw, one, z( krow,
673 $ kwtop ),
674 $ ldz, v, ldv, zero, wv, ldwv )
675 CALL slacpy( 'A', kln, jw, wv, ldwv, z( krow, kwtop ),
676 $ ldz )
677 90 CONTINUE
678 END IF
679 END IF
680*
681* ==== Return the number of deflations ... ====
682*
683 nd = jw - ns
684*
685* ==== ... and the number of shifts. (Subtracting
686* . INFQR from the spike length takes care
687* . of the case of a rare QR failure while
688* . calculating eigenvalues of the deflation
689* . window.) ====
690*
691 ns = ns - infqr
692*
693* ==== Return optimal workspace. ====
694*
695 work( 1 ) = sroundup_lwork( lwkopt )
696*
697* ==== End of SLAQR3 ====
698*
scopy
subroutine scopy(n, sx, incx, sy, incy)
SCOPY
Definition scopy.f:82
sgehrd
subroutine sgehrd(n, ilo, ihi, a, lda, tau, work, lwork, info)
SGEHRD
Definition sgehrd.f:166
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
slahqr
subroutine slahqr(wantt, wantz, n, ilo, ihi, h, ldh, wr, wi, iloz, ihiz, z, ldz, info)
SLAHQR computes the eigenvalues and Schur factorization of an upper Hessenberg matrix,...
Definition slahqr.f:205
slamch
real function slamch(cmach)
SLAMCH
Definition slamch.f:68
slanv2
subroutine slanv2(a, b, c, d, rt1r, rt1i, rt2r, rt2i, cs, sn)
SLANV2 computes the Schur factorization of a real 2-by-2 nonsymmetric matrix in standard form.
Definition slanv2.f:125
slaqr4
subroutine slaqr4(wantt, wantz, n, ilo, ihi, h, ldh, wr, wi, iloz, ihiz, z, ldz, work, lwork, info)
SLAQR4 computes the eigenvalues of a Hessenberg matrix, and optionally the matrices from the Schur de...
Definition slaqr4.f:263
slarfg
subroutine slarfg(n, alpha, x, incx, tau)
SLARFG generates an elementary reflector (Householder matrix).
Definition slarfg.f:104
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
sroundup_lwork
real function sroundup_lwork(lwork)
SROUNDUP_LWORK
Definition sroundup_lwork.f:59
strexc
subroutine strexc(compq, n, t, ldt, q, ldq, ifst, ilst, work, info)
STREXC
Definition strexc.f:146
sormhr
subroutine sormhr(side, trans, m, n, ilo, ihi, a, lda, tau, c, ldc, work, lwork, info)
SORMHR
Definition sormhr.f:177
slarf1f
subroutine slarf1f(side, m, n, v, incv, tau, c, ldc, work)
SLARF1F applies an elementary reflector to a general rectangular
Definition slarf1f.f:123
Here is the call graph for this function:
Here is the caller graph for this function: