LAPACK 3.11.0 LAPACK: Linear Algebra PACKage
Searching...
No Matches

◆ slarre()

 subroutine slarre ( character RANGE, integer N, real VL, real VU, integer IL, integer IU, real, dimension( * ) D, real, dimension( * ) E, real, dimension( * ) E2, real RTOL1, real RTOL2, real SPLTOL, integer NSPLIT, integer, dimension( * ) ISPLIT, integer M, real, dimension( * ) W, real, dimension( * ) WERR, real, dimension( * ) WGAP, integer, dimension( * ) IBLOCK, integer, dimension( * ) INDEXW, real, dimension( * ) GERS, real PIVMIN, real, dimension( * ) WORK, integer, dimension( * ) IWORK, integer INFO )

SLARRE given the tridiagonal matrix T, sets small off-diagonal elements to zero and for each unreduced block Ti, finds base representations and eigenvalues.

Purpose:
``` To find the desired eigenvalues of a given real symmetric
tridiagonal matrix T, SLARRE sets any "small" off-diagonal
elements to zero, and for each unreduced block T_i, it finds
(a) a suitable shift at one end of the block's spectrum,
(b) the base representation, T_i - sigma_i I = L_i D_i L_i^T, and
(c) eigenvalues of each L_i D_i L_i^T.
The representations and eigenvalues found are then used by
SSTEMR to compute the eigenvectors of T.
The accuracy varies depending on whether bisection is used to
find a few eigenvalues or the dqds algorithm (subroutine SLASQ2) to
conpute all and then discard any unwanted one.
As an added benefit, SLARRE also outputs the n
Gerschgorin intervals for the matrices L_i D_i L_i^T.```
Parameters
 [in] RANGE ``` RANGE is CHARACTER*1 = 'A': ("All") all eigenvalues will be found. = 'V': ("Value") all eigenvalues in the half-open interval (VL, VU] will be found. = 'I': ("Index") the IL-th through IU-th eigenvalues (of the entire matrix) will be found.``` [in] N ``` N is INTEGER The order of the matrix. N > 0.``` [in,out] VL ``` VL is REAL If RANGE='V', the lower bound for the eigenvalues. Eigenvalues less than or equal to VL, or greater than VU, will not be returned. VL < VU. If RANGE='I' or ='A', SLARRE computes bounds on the desired part of the spectrum.``` [in,out] VU ``` VU is REAL If RANGE='V', the upper bound for the eigenvalues. Eigenvalues less than or equal to VL, or greater than VU, will not be returned. VL < VU. If RANGE='I' or ='A', SLARRE computes bounds on the desired part of the spectrum.``` [in] IL ``` IL is INTEGER If RANGE='I', the index of the smallest eigenvalue to be returned. 1 <= IL <= IU <= N.``` [in] IU ``` IU is INTEGER If RANGE='I', the index of the largest eigenvalue to be returned. 1 <= IL <= IU <= N.``` [in,out] D ``` D is REAL array, dimension (N) On entry, the N diagonal elements of the tridiagonal matrix T. On exit, the N diagonal elements of the diagonal matrices D_i.``` [in,out] E ``` E is REAL array, dimension (N) On entry, the first (N-1) entries contain the subdiagonal elements of the tridiagonal matrix T; E(N) need not be set. On exit, E contains the subdiagonal elements of the unit bidiagonal matrices L_i. The entries E( ISPLIT( I ) ), 1 <= I <= NSPLIT, contain the base points sigma_i on output.``` [in,out] E2 ``` E2 is REAL array, dimension (N) On entry, the first (N-1) entries contain the SQUARES of the subdiagonal elements of the tridiagonal matrix T; E2(N) need not be set. On exit, the entries E2( ISPLIT( I ) ), 1 <= I <= NSPLIT, have been set to zero``` [in] RTOL1 ` RTOL1 is REAL` [in] RTOL2 ``` RTOL2 is REAL Parameters for bisection. An interval [LEFT,RIGHT] has converged if RIGHT-LEFT < MAX( RTOL1*GAP, RTOL2*MAX(|LEFT|,|RIGHT|) )``` [in] SPLTOL ``` SPLTOL is REAL The threshold for splitting.``` [out] NSPLIT ``` NSPLIT is INTEGER The number of blocks T splits into. 1 <= NSPLIT <= N.``` [out] ISPLIT ``` ISPLIT is INTEGER array, dimension (N) The splitting points, at which T breaks up into blocks. The first block consists of rows/columns 1 to ISPLIT(1), the second of rows/columns ISPLIT(1)+1 through ISPLIT(2), etc., and the NSPLIT-th consists of rows/columns ISPLIT(NSPLIT-1)+1 through ISPLIT(NSPLIT)=N.``` [out] M ``` M is INTEGER The total number of eigenvalues (of all L_i D_i L_i^T) found.``` [out] W ``` W is REAL array, dimension (N) The first M elements contain the eigenvalues. The eigenvalues of each of the blocks, L_i D_i L_i^T, are sorted in ascending order ( SLARRE may use the remaining N-M elements as workspace).``` [out] WERR ``` WERR is REAL array, dimension (N) The error bound on the corresponding eigenvalue in W.``` [out] WGAP ``` WGAP is REAL array, dimension (N) The separation from the right neighbor eigenvalue in W. The gap is only with respect to the eigenvalues of the same block as each block has its own representation tree. Exception: at the right end of a block we store the left gap``` [out] IBLOCK ``` IBLOCK is INTEGER array, dimension (N) The indices of the blocks (submatrices) associated with the corresponding eigenvalues in W; IBLOCK(i)=1 if eigenvalue W(i) belongs to the first block from the top, =2 if W(i) belongs to the second block, etc.``` [out] INDEXW ``` INDEXW is INTEGER array, dimension (N) The indices of the eigenvalues within each block (submatrix); for example, INDEXW(i)= 10 and IBLOCK(i)=2 imply that the i-th eigenvalue W(i) is the 10-th eigenvalue in block 2``` [out] GERS ``` GERS is REAL array, dimension (2*N) The N Gerschgorin intervals (the i-th Gerschgorin interval is (GERS(2*i-1), GERS(2*i)).``` [out] PIVMIN ``` PIVMIN is REAL The minimum pivot in the Sturm sequence for T.``` [out] WORK ``` WORK is REAL array, dimension (6*N) Workspace.``` [out] IWORK ``` IWORK is INTEGER array, dimension (5*N) Workspace.``` [out] INFO ``` INFO is INTEGER = 0: successful exit > 0: A problem occurred in SLARRE. < 0: One of the called subroutines signaled an internal problem. Needs inspection of the corresponding parameter IINFO for further information. =-1: Problem in SLARRD. = 2: No base representation could be found in MAXTRY iterations. Increasing MAXTRY and recompilation might be a remedy. =-3: Problem in SLARRB when computing the refined root representation for SLASQ2. =-4: Problem in SLARRB when preforming bisection on the desired part of the spectrum. =-5: Problem in SLASQ2. =-6: Problem in SLASQ2.```
Further Details:
```  The base representations are required to suffer very little
element growth and consequently define all their eigenvalues to
high relative accuracy.```
Contributors:
Beresford Parlett, University of California, Berkeley, USA
Jim Demmel, University of California, Berkeley, USA
Inderjit Dhillon, University of Texas, Austin, USA
Osni Marques, LBNL/NERSC, USA
Christof Voemel, University of California, Berkeley, USA

Definition at line 301 of file slarre.f.

305*
306* -- LAPACK auxiliary routine --
307* -- LAPACK is a software package provided by Univ. of Tennessee, --
308* -- Univ. of California Berkeley, Univ. of Colorado Denver and NAG Ltd..--
309*
310* .. Scalar Arguments ..
311 CHARACTER RANGE
312 INTEGER IL, INFO, IU, M, N, NSPLIT
313 REAL PIVMIN, RTOL1, RTOL2, SPLTOL, VL, VU
314* ..
315* .. Array Arguments ..
316 INTEGER IBLOCK( * ), ISPLIT( * ), IWORK( * ),
317 \$ INDEXW( * )
318 REAL D( * ), E( * ), E2( * ), GERS( * ),
319 \$ W( * ),WERR( * ), WGAP( * ), WORK( * )
320* ..
321*
322* =====================================================================
323*
324* .. Parameters ..
325 REAL FAC, FOUR, FOURTH, FUDGE, HALF, HNDRD,
326 \$ MAXGROWTH, ONE, PERT, TWO, ZERO
327 parameter( zero = 0.0e0, one = 1.0e0,
328 \$ two = 2.0e0, four=4.0e0,
329 \$ hndrd = 100.0e0,
330 \$ pert = 4.0e0,
331 \$ half = one/two, fourth = one/four, fac= half,
332 \$ maxgrowth = 64.0e0, fudge = 2.0e0 )
333 INTEGER MAXTRY, ALLRNG, INDRNG, VALRNG
334 parameter( maxtry = 6, allrng = 1, indrng = 2,
335 \$ valrng = 3 )
336* ..
337* .. Local Scalars ..
338 LOGICAL FORCEB, NOREP, USEDQD
339 INTEGER CNT, CNT1, CNT2, I, IBEGIN, IDUM, IEND, IINFO,
340 \$ IN, INDL, INDU, IRANGE, J, JBLK, MB, MM,
341 \$ WBEGIN, WEND
342 REAL AVGAP, BSRTOL, CLWDTH, DMAX, DPIVOT, EABS,
343 \$ EMAX, EOLD, EPS, GL, GU, ISLEFT, ISRGHT, RTL,
344 \$ RTOL, S1, S2, SAFMIN, SGNDEF, SIGMA, SPDIAM,
345 \$ TAU, TMP, TMP1
346
347
348* ..
349* .. Local Arrays ..
350 INTEGER ISEED( 4 )
351* ..
352* .. External Functions ..
353 LOGICAL LSAME
354 REAL SLAMCH
355 EXTERNAL slamch, lsame
356
357* ..
358* .. External Subroutines ..
359 EXTERNAL scopy, slarnv, slarra, slarrb, slarrc, slarrd,
360 \$ slasq2, slarrk
361* ..
362* .. Intrinsic Functions ..
363 INTRINSIC abs, max, min
364
365* ..
366* .. Executable Statements ..
367*
368
369 info = 0
370*
371* Quick return if possible
372*
373 IF( n.LE.0 ) THEN
374 RETURN
375 END IF
376*
377* Decode RANGE
378*
379 IF( lsame( range, 'A' ) ) THEN
380 irange = allrng
381 ELSE IF( lsame( range, 'V' ) ) THEN
382 irange = valrng
383 ELSE IF( lsame( range, 'I' ) ) THEN
384 irange = indrng
385 END IF
386
387 m = 0
388
389* Get machine constants
390 safmin = slamch( 'S' )
391 eps = slamch( 'P' )
392
393* Set parameters
394 rtl = hndrd*eps
395* If one were ever to ask for less initial precision in BSRTOL,
396* one should keep in mind that for the subset case, the extremal
397* eigenvalues must be at least as accurate as the current setting
398* (eigenvalues in the middle need not as much accuracy)
399 bsrtol = sqrt(eps)*(0.5e-3)
400
401* Treat case of 1x1 matrix for quick return
402 IF( n.EQ.1 ) THEN
403 IF( (irange.EQ.allrng).OR.
404 \$ ((irange.EQ.valrng).AND.(d(1).GT.vl).AND.(d(1).LE.vu)).OR.
405 \$ ((irange.EQ.indrng).AND.(il.EQ.1).AND.(iu.EQ.1)) ) THEN
406 m = 1
407 w(1) = d(1)
408* The computation error of the eigenvalue is zero
409 werr(1) = zero
410 wgap(1) = zero
411 iblock( 1 ) = 1
412 indexw( 1 ) = 1
413 gers(1) = d( 1 )
414 gers(2) = d( 1 )
415 ENDIF
416* store the shift for the initial RRR, which is zero in this case
417 e(1) = zero
418 RETURN
419 END IF
420
421* General case: tridiagonal matrix of order > 1
422*
423* Init WERR, WGAP. Compute Gerschgorin intervals and spectral diameter.
424* Compute maximum off-diagonal entry and pivmin.
425 gl = d(1)
426 gu = d(1)
427 eold = zero
428 emax = zero
429 e(n) = zero
430 DO 5 i = 1,n
431 werr(i) = zero
432 wgap(i) = zero
433 eabs = abs( e(i) )
434 IF( eabs .GE. emax ) THEN
435 emax = eabs
436 END IF
437 tmp1 = eabs + eold
438 gers( 2*i-1) = d(i) - tmp1
439 gl = min( gl, gers( 2*i - 1))
440 gers( 2*i ) = d(i) + tmp1
441 gu = max( gu, gers(2*i) )
442 eold = eabs
443 5 CONTINUE
444* The minimum pivot allowed in the Sturm sequence for T
445 pivmin = safmin * max( one, emax**2 )
446* Compute spectral diameter. The Gerschgorin bounds give an
447* estimate that is wrong by at most a factor of SQRT(2)
448 spdiam = gu - gl
449
450* Compute splitting points
451 CALL slarra( n, d, e, e2, spltol, spdiam,
452 \$ nsplit, isplit, iinfo )
453
454* Can force use of bisection instead of faster DQDS.
455* Option left in the code for future multisection work.
456 forceb = .false.
457
458* Initialize USEDQD, DQDS should be used for ALLRNG unless someone
459* explicitly wants bisection.
460 usedqd = (( irange.EQ.allrng ) .AND. (.NOT.forceb))
461
462 IF( (irange.EQ.allrng) .AND. (.NOT. forceb) ) THEN
463* Set interval [VL,VU] that contains all eigenvalues
464 vl = gl
465 vu = gu
466 ELSE
467* We call SLARRD to find crude approximations to the eigenvalues
468* in the desired range. In case IRANGE = INDRNG, we also obtain the
469* interval (VL,VU] that contains all the wanted eigenvalues.
470* An interval [LEFT,RIGHT] has converged if
471* RIGHT-LEFT.LT.RTOL*MAX(ABS(LEFT),ABS(RIGHT))
472* SLARRD needs a WORK of size 4*N, IWORK of size 3*N
473 CALL slarrd( range, 'B', n, vl, vu, il, iu, gers,
474 \$ bsrtol, d, e, e2, pivmin, nsplit, isplit,
475 \$ mm, w, werr, vl, vu, iblock, indexw,
476 \$ work, iwork, iinfo )
477 IF( iinfo.NE.0 ) THEN
478 info = -1
479 RETURN
480 ENDIF
481* Make sure that the entries M+1 to N in W, WERR, IBLOCK, INDEXW are 0
482 DO 14 i = mm+1,n
483 w( i ) = zero
484 werr( i ) = zero
485 iblock( i ) = 0
486 indexw( i ) = 0
487 14 CONTINUE
488 END IF
489
490
491***
492* Loop over unreduced blocks
493 ibegin = 1
494 wbegin = 1
495 DO 170 jblk = 1, nsplit
496 iend = isplit( jblk )
497 in = iend - ibegin + 1
498
499* 1 X 1 block
500 IF( in.EQ.1 ) THEN
501 IF( (irange.EQ.allrng).OR.( (irange.EQ.valrng).AND.
502 \$ ( d( ibegin ).GT.vl ).AND.( d( ibegin ).LE.vu ) )
503 \$ .OR. ( (irange.EQ.indrng).AND.(iblock(wbegin).EQ.jblk))
504 \$ ) THEN
505 m = m + 1
506 w( m ) = d( ibegin )
507 werr(m) = zero
508* The gap for a single block doesn't matter for the later
509* algorithm and is assigned an arbitrary large value
510 wgap(m) = zero
511 iblock( m ) = jblk
512 indexw( m ) = 1
513 wbegin = wbegin + 1
514 ENDIF
515* E( IEND ) holds the shift for the initial RRR
516 e( iend ) = zero
517 ibegin = iend + 1
518 GO TO 170
519 END IF
520*
521* Blocks of size larger than 1x1
522*
523* E( IEND ) will hold the shift for the initial RRR, for now set it =0
524 e( iend ) = zero
525*
526* Find local outer bounds GL,GU for the block
527 gl = d(ibegin)
528 gu = d(ibegin)
529 DO 15 i = ibegin , iend
530 gl = min( gers( 2*i-1 ), gl )
531 gu = max( gers( 2*i ), gu )
532 15 CONTINUE
533 spdiam = gu - gl
534
535 IF(.NOT. ((irange.EQ.allrng).AND.(.NOT.forceb)) ) THEN
536* Count the number of eigenvalues in the current block.
537 mb = 0
538 DO 20 i = wbegin,mm
539 IF( iblock(i).EQ.jblk ) THEN
540 mb = mb+1
541 ELSE
542 GOTO 21
543 ENDIF
544 20 CONTINUE
545 21 CONTINUE
546
547 IF( mb.EQ.0) THEN
548* No eigenvalue in the current block lies in the desired range
549* E( IEND ) holds the shift for the initial RRR
550 e( iend ) = zero
551 ibegin = iend + 1
552 GO TO 170
553 ELSE
554
555* Decide whether dqds or bisection is more efficient
556 usedqd = ( (mb .GT. fac*in) .AND. (.NOT.forceb) )
557 wend = wbegin + mb - 1
558* Calculate gaps for the current block
559* In later stages, when representations for individual
560* eigenvalues are different, we use SIGMA = E( IEND ).
561 sigma = zero
562 DO 30 i = wbegin, wend - 1
563 wgap( i ) = max( zero,
564 \$ w(i+1)-werr(i+1) - (w(i)+werr(i)) )
565 30 CONTINUE
566 wgap( wend ) = max( zero,
567 \$ vu - sigma - (w( wend )+werr( wend )))
568* Find local index of the first and last desired evalue.
569 indl = indexw(wbegin)
570 indu = indexw( wend )
571 ENDIF
572 ENDIF
573 IF(( (irange.EQ.allrng) .AND. (.NOT. forceb) ).OR.usedqd) THEN
574* Case of DQDS
575* Find approximations to the extremal eigenvalues of the block
576 CALL slarrk( in, 1, gl, gu, d(ibegin),
577 \$ e2(ibegin), pivmin, rtl, tmp, tmp1, iinfo )
578 IF( iinfo.NE.0 ) THEN
579 info = -1
580 RETURN
581 ENDIF
582 isleft = max(gl, tmp - tmp1
583 \$ - hndrd * eps* abs(tmp - tmp1))
584
585 CALL slarrk( in, in, gl, gu, d(ibegin),
586 \$ e2(ibegin), pivmin, rtl, tmp, tmp1, iinfo )
587 IF( iinfo.NE.0 ) THEN
588 info = -1
589 RETURN
590 ENDIF
591 isrght = min(gu, tmp + tmp1
592 \$ + hndrd * eps * abs(tmp + tmp1))
593* Improve the estimate of the spectral diameter
594 spdiam = isrght - isleft
595 ELSE
596* Case of bisection
597* Find approximations to the wanted extremal eigenvalues
598 isleft = max(gl, w(wbegin) - werr(wbegin)
599 \$ - hndrd * eps*abs(w(wbegin)- werr(wbegin) ))
600 isrght = min(gu,w(wend) + werr(wend)
601 \$ + hndrd * eps * abs(w(wend)+ werr(wend)))
602 ENDIF
603
604
605* Decide whether the base representation for the current block
606* L_JBLK D_JBLK L_JBLK^T = T_JBLK - sigma_JBLK I
607* should be on the left or the right end of the current block.
608* The strategy is to shift to the end which is "more populated"
609* Furthermore, decide whether to use DQDS for the computation of
610* the eigenvalue approximations at the end of SLARRE or bisection.
611* dqds is chosen if all eigenvalues are desired or the number of
612* eigenvalues to be computed is large compared to the blocksize.
613 IF( ( irange.EQ.allrng ) .AND. (.NOT.forceb) ) THEN
614* If all the eigenvalues have to be computed, we use dqd
615 usedqd = .true.
616* INDL is the local index of the first eigenvalue to compute
617 indl = 1
618 indu = in
619* MB = number of eigenvalues to compute
620 mb = in
621 wend = wbegin + mb - 1
622* Define 1/4 and 3/4 points of the spectrum
623 s1 = isleft + fourth * spdiam
624 s2 = isrght - fourth * spdiam
625 ELSE
626* SLARRD has computed IBLOCK and INDEXW for each eigenvalue
627* approximation.
628* choose sigma
629 IF( usedqd ) THEN
630 s1 = isleft + fourth * spdiam
631 s2 = isrght - fourth * spdiam
632 ELSE
633 tmp = min(isrght,vu) - max(isleft,vl)
634 s1 = max(isleft,vl) + fourth * tmp
635 s2 = min(isrght,vu) - fourth * tmp
636 ENDIF
637 ENDIF
638
639* Compute the negcount at the 1/4 and 3/4 points
640 IF(mb.GT.1) THEN
641 CALL slarrc( 'T', in, s1, s2, d(ibegin),
642 \$ e(ibegin), pivmin, cnt, cnt1, cnt2, iinfo)
643 ENDIF
644
645 IF(mb.EQ.1) THEN
646 sigma = gl
647 sgndef = one
648 ELSEIF( cnt1 - indl .GE. indu - cnt2 ) THEN
649 IF( ( irange.EQ.allrng ) .AND. (.NOT.forceb) ) THEN
650 sigma = max(isleft,gl)
651 ELSEIF( usedqd ) THEN
652* use Gerschgorin bound as shift to get pos def matrix
653* for dqds
654 sigma = isleft
655 ELSE
656* use approximation of the first desired eigenvalue of the
657* block as shift
658 sigma = max(isleft,vl)
659 ENDIF
660 sgndef = one
661 ELSE
662 IF( ( irange.EQ.allrng ) .AND. (.NOT.forceb) ) THEN
663 sigma = min(isrght,gu)
664 ELSEIF( usedqd ) THEN
665* use Gerschgorin bound as shift to get neg def matrix
666* for dqds
667 sigma = isrght
668 ELSE
669* use approximation of the first desired eigenvalue of the
670* block as shift
671 sigma = min(isrght,vu)
672 ENDIF
673 sgndef = -one
674 ENDIF
675
676
677* An initial SIGMA has been chosen that will be used for computing
678* T - SIGMA I = L D L^T
679* Define the increment TAU of the shift in case the initial shift
680* needs to be refined to obtain a factorization with not too much
681* element growth.
682 IF( usedqd ) THEN
683* The initial SIGMA was to the outer end of the spectrum
684* the matrix is definite and we need not retreat.
685 tau = spdiam*eps*n + two*pivmin
686 tau = max( tau,two*eps*abs(sigma) )
687 ELSE
688 IF(mb.GT.1) THEN
689 clwdth = w(wend) + werr(wend) - w(wbegin) - werr(wbegin)
690 avgap = abs(clwdth / real(wend-wbegin))
691 IF( sgndef.EQ.one ) THEN
692 tau = half*max(wgap(wbegin),avgap)
693 tau = max(tau,werr(wbegin))
694 ELSE
695 tau = half*max(wgap(wend-1),avgap)
696 tau = max(tau,werr(wend))
697 ENDIF
698 ELSE
699 tau = werr(wbegin)
700 ENDIF
701 ENDIF
702*
703 DO 80 idum = 1, maxtry
704* Compute L D L^T factorization of tridiagonal matrix T - sigma I.
705* Store D in WORK(1:IN), L in WORK(IN+1:2*IN), and reciprocals of
706* pivots in WORK(2*IN+1:3*IN)
707 dpivot = d( ibegin ) - sigma
708 work( 1 ) = dpivot
709 dmax = abs( work(1) )
710 j = ibegin
711 DO 70 i = 1, in - 1
712 work( 2*in+i ) = one / work( i )
713 tmp = e( j )*work( 2*in+i )
714 work( in+i ) = tmp
715 dpivot = ( d( j+1 )-sigma ) - tmp*e( j )
716 work( i+1 ) = dpivot
717 dmax = max( dmax, abs(dpivot) )
718 j = j + 1
719 70 CONTINUE
720* check for element growth
721 IF( dmax .GT. maxgrowth*spdiam ) THEN
722 norep = .true.
723 ELSE
724 norep = .false.
725 ENDIF
726 IF( usedqd .AND. .NOT.norep ) THEN
727* Ensure the definiteness of the representation
728* All entries of D (of L D L^T) must have the same sign
729 DO 71 i = 1, in
730 tmp = sgndef*work( i )
731 IF( tmp.LT.zero ) norep = .true.
732 71 CONTINUE
733 ENDIF
734 IF(norep) THEN
735* Note that in the case of IRANGE=ALLRNG, we use the Gerschgorin
736* shift which makes the matrix definite. So we should end up
737* here really only in the case of IRANGE = VALRNG or INDRNG.
738 IF( idum.EQ.maxtry-1 ) THEN
739 IF( sgndef.EQ.one ) THEN
740* The fudged Gerschgorin shift should succeed
741 sigma =
742 \$ gl - fudge*spdiam*eps*n - fudge*two*pivmin
743 ELSE
744 sigma =
745 \$ gu + fudge*spdiam*eps*n + fudge*two*pivmin
746 END IF
747 ELSE
748 sigma = sigma - sgndef * tau
749 tau = two * tau
750 END IF
751 ELSE
752* an initial RRR is found
753 GO TO 83
754 END IF
755 80 CONTINUE
756* if the program reaches this point, no base representation could be
757* found in MAXTRY iterations.
758 info = 2
759 RETURN
760
761 83 CONTINUE
762* At this point, we have found an initial base representation
763* T - SIGMA I = L D L^T with not too much element growth.
764* Store the shift.
765 e( iend ) = sigma
766* Store D and L.
767 CALL scopy( in, work, 1, d( ibegin ), 1 )
768 CALL scopy( in-1, work( in+1 ), 1, e( ibegin ), 1 )
769
770
771 IF(mb.GT.1 ) THEN
772*
773* Perturb each entry of the base representation by a small
774* (but random) relative amount to overcome difficulties with
775* glued matrices.
776*
777 DO 122 i = 1, 4
778 iseed( i ) = 1
779 122 CONTINUE
780
781 CALL slarnv(2, iseed, 2*in-1, work(1))
782 DO 125 i = 1,in-1
783 d(ibegin+i-1) = d(ibegin+i-1)*(one+eps*pert*work(i))
784 e(ibegin+i-1) = e(ibegin+i-1)*(one+eps*pert*work(in+i))
785 125 CONTINUE
786 d(iend) = d(iend)*(one+eps*four*work(in))
787*
788 ENDIF
789*
790* Don't update the Gerschgorin intervals because keeping track
791* of the updates would be too much work in SLARRV.
792* We update W instead and use it to locate the proper Gerschgorin
793* intervals.
794
795* Compute the required eigenvalues of L D L' by bisection or dqds
796 IF ( .NOT.usedqd ) THEN
797* If SLARRD has been used, shift the eigenvalue approximations
798* according to their representation. This is necessary for
799* a uniform SLARRV since dqds computes eigenvalues of the
800* shifted representation. In SLARRV, W will always hold the
801* UNshifted eigenvalue approximation.
802 DO 134 j=wbegin,wend
803 w(j) = w(j) - sigma
804 werr(j) = werr(j) + abs(w(j)) * eps
805 134 CONTINUE
806* call SLARRB to reduce eigenvalue error of the approximations
807* from SLARRD
808 DO 135 i = ibegin, iend-1
809 work( i ) = d( i ) * e( i )**2
810 135 CONTINUE
811* use bisection to find EV from INDL to INDU
812 CALL slarrb(in, d(ibegin), work(ibegin),
813 \$ indl, indu, rtol1, rtol2, indl-1,
814 \$ w(wbegin), wgap(wbegin), werr(wbegin),
815 \$ work( 2*n+1 ), iwork, pivmin, spdiam,
816 \$ in, iinfo )
817 IF( iinfo .NE. 0 ) THEN
818 info = -4
819 RETURN
820 END IF
821* SLARRB computes all gaps correctly except for the last one
822* Record distance to VU/GU
823 wgap( wend ) = max( zero,
824 \$ ( vu-sigma ) - ( w( wend ) + werr( wend ) ) )
825 DO 138 i = indl, indu
826 m = m + 1
827 iblock(m) = jblk
828 indexw(m) = i
829 138 CONTINUE
830 ELSE
831* Call dqds to get all eigs (and then possibly delete unwanted
832* eigenvalues).
833* Note that dqds finds the eigenvalues of the L D L^T representation
834* of T to high relative accuracy. High relative accuracy
835* might be lost when the shift of the RRR is subtracted to obtain
836* the eigenvalues of T. However, T is not guaranteed to define its
837* eigenvalues to high relative accuracy anyway.
838* Set RTOL to the order of the tolerance used in SLASQ2
839* This is an ESTIMATED error, the worst case bound is 4*N*EPS
840* which is usually too large and requires unnecessary work to be
841* done by bisection when computing the eigenvectors
842 rtol = log(real(in)) * four * eps
843 j = ibegin
844 DO 140 i = 1, in - 1
845 work( 2*i-1 ) = abs( d( j ) )
846 work( 2*i ) = e( j )*e( j )*work( 2*i-1 )
847 j = j + 1
848 140 CONTINUE
849 work( 2*in-1 ) = abs( d( iend ) )
850 work( 2*in ) = zero
851 CALL slasq2( in, work, iinfo )
852 IF( iinfo .NE. 0 ) THEN
853* If IINFO = -5 then an index is part of a tight cluster
854* and should be changed. The index is in IWORK(1) and the
855* gap is in WORK(N+1)
856 info = -5
857 RETURN
858 ELSE
859* Test that all eigenvalues are positive as expected
860 DO 149 i = 1, in
861 IF( work( i ).LT.zero ) THEN
862 info = -6
863 RETURN
864 ENDIF
865 149 CONTINUE
866 END IF
867 IF( sgndef.GT.zero ) THEN
868 DO 150 i = indl, indu
869 m = m + 1
870 w( m ) = work( in-i+1 )
871 iblock( m ) = jblk
872 indexw( m ) = i
873 150 CONTINUE
874 ELSE
875 DO 160 i = indl, indu
876 m = m + 1
877 w( m ) = -work( i )
878 iblock( m ) = jblk
879 indexw( m ) = i
880 160 CONTINUE
881 END IF
882
883 DO 165 i = m - mb + 1, m
884* the value of RTOL below should be the tolerance in SLASQ2
885 werr( i ) = rtol * abs( w(i) )
886 165 CONTINUE
887 DO 166 i = m - mb + 1, m - 1
888* compute the right gap between the intervals
889 wgap( i ) = max( zero,
890 \$ w(i+1)-werr(i+1) - (w(i)+werr(i)) )
891 166 CONTINUE
892 wgap( m ) = max( zero,
893 \$ ( vu-sigma ) - ( w( m ) + werr( m ) ) )
894 END IF
895* proceed with next block
896 ibegin = iend + 1
897 wbegin = wend + 1
898 170 CONTINUE
899*
900
901 RETURN
902*
903* End of SLARRE
904*
subroutine slarrd(RANGE, ORDER, N, VL, VU, IL, IU, GERS, RELTOL, D, E, E2, PIVMIN, NSPLIT, ISPLIT, M, W, WERR, WL, WU, IBLOCK, INDEXW, WORK, IWORK, INFO)
SLARRD computes the eigenvalues of a symmetric tridiagonal matrix to suitable accuracy.
Definition: slarrd.f:329
subroutine slarnv(IDIST, ISEED, N, X)
SLARNV returns a vector of random numbers from a uniform or normal distribution.
Definition: slarnv.f:97
subroutine slarrc(JOBT, N, VL, VU, D, E, PIVMIN, EIGCNT, LCNT, RCNT, INFO)
SLARRC computes the number of eigenvalues of the symmetric tridiagonal matrix.
Definition: slarrc.f:137
subroutine slarra(N, D, E, E2, SPLTOL, TNRM, NSPLIT, ISPLIT, INFO)
SLARRA computes the splitting points with the specified threshold.
Definition: slarra.f:136
subroutine slarrk(N, IW, GL, GU, D, E2, PIVMIN, RELTOL, W, WERR, INFO)
SLARRK computes one eigenvalue of a symmetric tridiagonal matrix T to suitable accuracy.
Definition: slarrk.f:145
subroutine slarrb(N, D, LLD, IFIRST, ILAST, RTOL1, RTOL2, OFFSET, W, WGAP, WERR, WORK, IWORK, PIVMIN, SPDIAM, TWIST, INFO)
SLARRB provides limited bisection to locate eigenvalues for more accuracy.
Definition: slarrb.f:196
logical function lsame(CA, CB)
LSAME
Definition: lsame.f:53
subroutine slasq2(N, Z, INFO)
SLASQ2 computes all the eigenvalues of the symmetric positive definite tridiagonal matrix associated ...
Definition: slasq2.f:112
subroutine scopy(N, SX, INCX, SY, INCY)
SCOPY
Definition: scopy.f:82
real function slamch(CMACH)
SLAMCH
Definition: slamch.f:68
Here is the call graph for this function:
Here is the caller graph for this function: