LAPACK  3.6.1
LAPACK: Linear Algebra PACKage
zlar1v.f
Go to the documentation of this file.
1 *> \brief \b ZLAR1V computes the (scaled) r-th column of the inverse of the submatrix in rows b1 through bn of the tridiagonal matrix LDLT - λI.
2 *
3 * =========== DOCUMENTATION ===========
4 *
5 * Online html documentation available at
6 * http://www.netlib.org/lapack/explore-html/
7 *
8 *> \htmlonly
9 *> Download ZLAR1V + dependencies
10 *> <a href="http://www.netlib.org/cgi-bin/netlibfiles.tgz?format=tgz&filename=/lapack/lapack_routine/zlar1v.f">
11 *> [TGZ]</a>
12 *> <a href="http://www.netlib.org/cgi-bin/netlibfiles.zip?format=zip&filename=/lapack/lapack_routine/zlar1v.f">
13 *> [ZIP]</a>
14 *> <a href="http://www.netlib.org/cgi-bin/netlibfiles.txt?format=txt&filename=/lapack/lapack_routine/zlar1v.f">
15 *> [TXT]</a>
16 *> \endhtmlonly
17 *
18 * Definition:
19 * ===========
20 *
21 * SUBROUTINE ZLAR1V( N, B1, BN, LAMBDA, D, L, LD, LLD,
22 * PIVMIN, GAPTOL, Z, WANTNC, NEGCNT, ZTZ, MINGMA,
23 * R, ISUPPZ, NRMINV, RESID, RQCORR, WORK )
24 *
25 * .. Scalar Arguments ..
26 * LOGICAL WANTNC
27 * INTEGER B1, BN, N, NEGCNT, R
28 * DOUBLE PRECISION GAPTOL, LAMBDA, MINGMA, NRMINV, PIVMIN, RESID,
29 * $ RQCORR, ZTZ
30 * ..
31 * .. Array Arguments ..
32 * INTEGER ISUPPZ( * )
33 * DOUBLE PRECISION D( * ), L( * ), LD( * ), LLD( * ),
34 * $ WORK( * )
35 * COMPLEX*16 Z( * )
36 * ..
37 *
38 *
39 *> \par Purpose:
40 * =============
41 *>
42 *> \verbatim
43 *>
44 *> ZLAR1V computes the (scaled) r-th column of the inverse of
45 *> the sumbmatrix in rows B1 through BN of the tridiagonal matrix
46 *> L D L**T - sigma I. When sigma is close to an eigenvalue, the
47 *> computed vector is an accurate eigenvector. Usually, r corresponds
48 *> to the index where the eigenvector is largest in magnitude.
49 *> The following steps accomplish this computation :
50 *> (a) Stationary qd transform, L D L**T - sigma I = L(+) D(+) L(+)**T,
51 *> (b) Progressive qd transform, L D L**T - sigma I = U(-) D(-) U(-)**T,
52 *> (c) Computation of the diagonal elements of the inverse of
53 *> L D L**T - sigma I by combining the above transforms, and choosing
54 *> r as the index where the diagonal of the inverse is (one of the)
55 *> largest in magnitude.
56 *> (d) Computation of the (scaled) r-th column of the inverse using the
57 *> twisted factorization obtained by combining the top part of the
58 *> the stationary and the bottom part of the progressive transform.
59 *> \endverbatim
60 *
61 * Arguments:
62 * ==========
63 *
64 *> \param[in] N
65 *> \verbatim
66 *> N is INTEGER
67 *> The order of the matrix L D L**T.
68 *> \endverbatim
69 *>
70 *> \param[in] B1
71 *> \verbatim
72 *> B1 is INTEGER
73 *> First index of the submatrix of L D L**T.
74 *> \endverbatim
75 *>
76 *> \param[in] BN
77 *> \verbatim
78 *> BN is INTEGER
79 *> Last index of the submatrix of L D L**T.
80 *> \endverbatim
81 *>
82 *> \param[in] LAMBDA
83 *> \verbatim
84 *> LAMBDA is DOUBLE PRECISION
85 *> The shift. In order to compute an accurate eigenvector,
86 *> LAMBDA should be a good approximation to an eigenvalue
87 *> of L D L**T.
88 *> \endverbatim
89 *>
90 *> \param[in] L
91 *> \verbatim
92 *> L is DOUBLE PRECISION array, dimension (N-1)
93 *> The (n-1) subdiagonal elements of the unit bidiagonal matrix
94 *> L, in elements 1 to N-1.
95 *> \endverbatim
96 *>
97 *> \param[in] D
98 *> \verbatim
99 *> D is DOUBLE PRECISION array, dimension (N)
100 *> The n diagonal elements of the diagonal matrix D.
101 *> \endverbatim
102 *>
103 *> \param[in] LD
104 *> \verbatim
105 *> LD is DOUBLE PRECISION array, dimension (N-1)
106 *> The n-1 elements L(i)*D(i).
107 *> \endverbatim
108 *>
109 *> \param[in] LLD
110 *> \verbatim
111 *> LLD is DOUBLE PRECISION array, dimension (N-1)
112 *> The n-1 elements L(i)*L(i)*D(i).
113 *> \endverbatim
114 *>
115 *> \param[in] PIVMIN
116 *> \verbatim
117 *> PIVMIN is DOUBLE PRECISION
118 *> The minimum pivot in the Sturm sequence.
119 *> \endverbatim
120 *>
121 *> \param[in] GAPTOL
122 *> \verbatim
123 *> GAPTOL is DOUBLE PRECISION
124 *> Tolerance that indicates when eigenvector entries are negligible
125 *> w.r.t. their contribution to the residual.
126 *> \endverbatim
127 *>
128 *> \param[in,out] Z
129 *> \verbatim
130 *> Z is COMPLEX*16 array, dimension (N)
131 *> On input, all entries of Z must be set to 0.
132 *> On output, Z contains the (scaled) r-th column of the
133 *> inverse. The scaling is such that Z(R) equals 1.
134 *> \endverbatim
135 *>
136 *> \param[in] WANTNC
137 *> \verbatim
138 *> WANTNC is LOGICAL
139 *> Specifies whether NEGCNT has to be computed.
140 *> \endverbatim
141 *>
142 *> \param[out] NEGCNT
143 *> \verbatim
144 *> NEGCNT is INTEGER
145 *> If WANTNC is .TRUE. then NEGCNT = the number of pivots < pivmin
146 *> in the matrix factorization L D L**T, and NEGCNT = -1 otherwise.
147 *> \endverbatim
148 *>
149 *> \param[out] ZTZ
150 *> \verbatim
151 *> ZTZ is DOUBLE PRECISION
152 *> The square of the 2-norm of Z.
153 *> \endverbatim
154 *>
155 *> \param[out] MINGMA
156 *> \verbatim
157 *> MINGMA is DOUBLE PRECISION
158 *> The reciprocal of the largest (in magnitude) diagonal
159 *> element of the inverse of L D L**T - sigma I.
160 *> \endverbatim
161 *>
162 *> \param[in,out] R
163 *> \verbatim
164 *> R is INTEGER
165 *> The twist index for the twisted factorization used to
166 *> compute Z.
167 *> On input, 0 <= R <= N. If R is input as 0, R is set to
168 *> the index where (L D L**T - sigma I)^{-1} is largest
169 *> in magnitude. If 1 <= R <= N, R is unchanged.
170 *> On output, R contains the twist index used to compute Z.
171 *> Ideally, R designates the position of the maximum entry in the
172 *> eigenvector.
173 *> \endverbatim
174 *>
175 *> \param[out] ISUPPZ
176 *> \verbatim
177 *> ISUPPZ is INTEGER array, dimension (2)
178 *> The support of the vector in Z, i.e., the vector Z is
179 *> nonzero only in elements ISUPPZ(1) through ISUPPZ( 2 ).
180 *> \endverbatim
181 *>
182 *> \param[out] NRMINV
183 *> \verbatim
184 *> NRMINV is DOUBLE PRECISION
185 *> NRMINV = 1/SQRT( ZTZ )
186 *> \endverbatim
187 *>
188 *> \param[out] RESID
189 *> \verbatim
190 *> RESID is DOUBLE PRECISION
191 *> The residual of the FP vector.
192 *> RESID = ABS( MINGMA )/SQRT( ZTZ )
193 *> \endverbatim
194 *>
195 *> \param[out] RQCORR
196 *> \verbatim
197 *> RQCORR is DOUBLE PRECISION
198 *> The Rayleigh Quotient correction to LAMBDA.
199 *> RQCORR = MINGMA*TMP
200 *> \endverbatim
201 *>
202 *> \param[out] WORK
203 *> \verbatim
204 *> WORK is DOUBLE PRECISION array, dimension (4*N)
205 *> \endverbatim
206 *
207 * Authors:
208 * ========
209 *
210 *> \author Univ. of Tennessee
211 *> \author Univ. of California Berkeley
212 *> \author Univ. of Colorado Denver
213 *> \author NAG Ltd.
214 *
215 *> \date September 2012
216 *
217 *> \ingroup complex16OTHERauxiliary
218 *
219 *> \par Contributors:
220 * ==================
221 *>
222 *> Beresford Parlett, University of California, Berkeley, USA \n
223 *> Jim Demmel, University of California, Berkeley, USA \n
224 *> Inderjit Dhillon, University of Texas, Austin, USA \n
225 *> Osni Marques, LBNL/NERSC, USA \n
226 *> Christof Voemel, University of California, Berkeley, USA
227 *
228 * =====================================================================
229  SUBROUTINE zlar1v( N, B1, BN, LAMBDA, D, L, LD, LLD,
230  $ pivmin, gaptol, z, wantnc, negcnt, ztz, mingma,
231  $ r, isuppz, nrminv, resid, rqcorr, work )
232 *
233 * -- LAPACK auxiliary routine (version 3.4.2) --
234 * -- LAPACK is a software package provided by Univ. of Tennessee, --
235 * -- Univ. of California Berkeley, Univ. of Colorado Denver and NAG Ltd..--
236 * September 2012
237 *
238 * .. Scalar Arguments ..
239  LOGICAL WANTNC
240  INTEGER B1, BN, N, NEGCNT, R
241  DOUBLE PRECISION GAPTOL, LAMBDA, MINGMA, NRMINV, PIVMIN, RESID,
242  $ rqcorr, ztz
243 * ..
244 * .. Array Arguments ..
245  INTEGER ISUPPZ( * )
246  DOUBLE PRECISION D( * ), L( * ), LD( * ), LLD( * ),
247  $ work( * )
248  COMPLEX*16 Z( * )
249 * ..
250 *
251 * =====================================================================
252 *
253 * .. Parameters ..
254  DOUBLE PRECISION ZERO, ONE
255  parameter ( zero = 0.0d0, one = 1.0d0 )
256  COMPLEX*16 CONE
257  parameter ( cone = ( 1.0d0, 0.0d0 ) )
258 
259 * ..
260 * .. Local Scalars ..
261  LOGICAL SAWNAN1, SAWNAN2
262  INTEGER I, INDLPL, INDP, INDS, INDUMN, NEG1, NEG2, R1,
263  $ r2
264  DOUBLE PRECISION DMINUS, DPLUS, EPS, S, TMP
265 * ..
266 * .. External Functions ..
267  LOGICAL DISNAN
268  DOUBLE PRECISION DLAMCH
269  EXTERNAL disnan, dlamch
270 * ..
271 * .. Intrinsic Functions ..
272  INTRINSIC abs, dble
273 * ..
274 * .. Executable Statements ..
275 *
276  eps = dlamch( 'Precision' )
277 
278 
279  IF( r.EQ.0 ) THEN
280  r1 = b1
281  r2 = bn
282  ELSE
283  r1 = r
284  r2 = r
285  END IF
286 
287 * Storage for LPLUS
288  indlpl = 0
289 * Storage for UMINUS
290  indumn = n
291  inds = 2*n + 1
292  indp = 3*n + 1
293 
294  IF( b1.EQ.1 ) THEN
295  work( inds ) = zero
296  ELSE
297  work( inds+b1-1 ) = lld( b1-1 )
298  END IF
299 
300 *
301 * Compute the stationary transform (using the differential form)
302 * until the index R2.
303 *
304  sawnan1 = .false.
305  neg1 = 0
306  s = work( inds+b1-1 ) - lambda
307  DO 50 i = b1, r1 - 1
308  dplus = d( i ) + s
309  work( indlpl+i ) = ld( i ) / dplus
310  IF(dplus.LT.zero) neg1 = neg1 + 1
311  work( inds+i ) = s*work( indlpl+i )*l( i )
312  s = work( inds+i ) - lambda
313  50 CONTINUE
314  sawnan1 = disnan( s )
315  IF( sawnan1 ) GOTO 60
316  DO 51 i = r1, r2 - 1
317  dplus = d( i ) + s
318  work( indlpl+i ) = ld( i ) / dplus
319  work( inds+i ) = s*work( indlpl+i )*l( i )
320  s = work( inds+i ) - lambda
321  51 CONTINUE
322  sawnan1 = disnan( s )
323 *
324  60 CONTINUE
325  IF( sawnan1 ) THEN
326 * Runs a slower version of the above loop if a NaN is detected
327  neg1 = 0
328  s = work( inds+b1-1 ) - lambda
329  DO 70 i = b1, r1 - 1
330  dplus = d( i ) + s
331  IF(abs(dplus).LT.pivmin) dplus = -pivmin
332  work( indlpl+i ) = ld( i ) / dplus
333  IF(dplus.LT.zero) neg1 = neg1 + 1
334  work( inds+i ) = s*work( indlpl+i )*l( i )
335  IF( work( indlpl+i ).EQ.zero )
336  $ work( inds+i ) = lld( i )
337  s = work( inds+i ) - lambda
338  70 CONTINUE
339  DO 71 i = r1, r2 - 1
340  dplus = d( i ) + s
341  IF(abs(dplus).LT.pivmin) dplus = -pivmin
342  work( indlpl+i ) = ld( i ) / dplus
343  work( inds+i ) = s*work( indlpl+i )*l( i )
344  IF( work( indlpl+i ).EQ.zero )
345  $ work( inds+i ) = lld( i )
346  s = work( inds+i ) - lambda
347  71 CONTINUE
348  END IF
349 *
350 * Compute the progressive transform (using the differential form)
351 * until the index R1
352 *
353  sawnan2 = .false.
354  neg2 = 0
355  work( indp+bn-1 ) = d( bn ) - lambda
356  DO 80 i = bn - 1, r1, -1
357  dminus = lld( i ) + work( indp+i )
358  tmp = d( i ) / dminus
359  IF(dminus.LT.zero) neg2 = neg2 + 1
360  work( indumn+i ) = l( i )*tmp
361  work( indp+i-1 ) = work( indp+i )*tmp - lambda
362  80 CONTINUE
363  tmp = work( indp+r1-1 )
364  sawnan2 = disnan( tmp )
365 
366  IF( sawnan2 ) THEN
367 * Runs a slower version of the above loop if a NaN is detected
368  neg2 = 0
369  DO 100 i = bn-1, r1, -1
370  dminus = lld( i ) + work( indp+i )
371  IF(abs(dminus).LT.pivmin) dminus = -pivmin
372  tmp = d( i ) / dminus
373  IF(dminus.LT.zero) neg2 = neg2 + 1
374  work( indumn+i ) = l( i )*tmp
375  work( indp+i-1 ) = work( indp+i )*tmp - lambda
376  IF( tmp.EQ.zero )
377  $ work( indp+i-1 ) = d( i ) - lambda
378  100 CONTINUE
379  END IF
380 *
381 * Find the index (from R1 to R2) of the largest (in magnitude)
382 * diagonal element of the inverse
383 *
384  mingma = work( inds+r1-1 ) + work( indp+r1-1 )
385  IF( mingma.LT.zero ) neg1 = neg1 + 1
386  IF( wantnc ) THEN
387  negcnt = neg1 + neg2
388  ELSE
389  negcnt = -1
390  ENDIF
391  IF( abs(mingma).EQ.zero )
392  $ mingma = eps*work( inds+r1-1 )
393  r = r1
394  DO 110 i = r1, r2 - 1
395  tmp = work( inds+i ) + work( indp+i )
396  IF( tmp.EQ.zero )
397  $ tmp = eps*work( inds+i )
398  IF( abs( tmp ).LE.abs( mingma ) ) THEN
399  mingma = tmp
400  r = i + 1
401  END IF
402  110 CONTINUE
403 *
404 * Compute the FP vector: solve N^T v = e_r
405 *
406  isuppz( 1 ) = b1
407  isuppz( 2 ) = bn
408  z( r ) = cone
409  ztz = one
410 *
411 * Compute the FP vector upwards from R
412 *
413  IF( .NOT.sawnan1 .AND. .NOT.sawnan2 ) THEN
414  DO 210 i = r-1, b1, -1
415  z( i ) = -( work( indlpl+i )*z( i+1 ) )
416  IF( (abs(z(i))+abs(z(i+1)))* abs(ld(i)).LT.gaptol )
417  $ THEN
418  z( i ) = zero
419  isuppz( 1 ) = i + 1
420  GOTO 220
421  ENDIF
422  ztz = ztz + dble( z( i )*z( i ) )
423  210 CONTINUE
424  220 CONTINUE
425  ELSE
426 * Run slower loop if NaN occurred.
427  DO 230 i = r - 1, b1, -1
428  IF( z( i+1 ).EQ.zero ) THEN
429  z( i ) = -( ld( i+1 ) / ld( i ) )*z( i+2 )
430  ELSE
431  z( i ) = -( work( indlpl+i )*z( i+1 ) )
432  END IF
433  IF( (abs(z(i))+abs(z(i+1)))* abs(ld(i)).LT.gaptol )
434  $ THEN
435  z( i ) = zero
436  isuppz( 1 ) = i + 1
437  GO TO 240
438  END IF
439  ztz = ztz + dble( z( i )*z( i ) )
440  230 CONTINUE
441  240 CONTINUE
442  ENDIF
443 
444 * Compute the FP vector downwards from R in blocks of size BLKSIZ
445  IF( .NOT.sawnan1 .AND. .NOT.sawnan2 ) THEN
446  DO 250 i = r, bn-1
447  z( i+1 ) = -( work( indumn+i )*z( i ) )
448  IF( (abs(z(i))+abs(z(i+1)))* abs(ld(i)).LT.gaptol )
449  $ THEN
450  z( i+1 ) = zero
451  isuppz( 2 ) = i
452  GO TO 260
453  END IF
454  ztz = ztz + dble( z( i+1 )*z( i+1 ) )
455  250 CONTINUE
456  260 CONTINUE
457  ELSE
458 * Run slower loop if NaN occurred.
459  DO 270 i = r, bn - 1
460  IF( z( i ).EQ.zero ) THEN
461  z( i+1 ) = -( ld( i-1 ) / ld( i ) )*z( i-1 )
462  ELSE
463  z( i+1 ) = -( work( indumn+i )*z( i ) )
464  END IF
465  IF( (abs(z(i))+abs(z(i+1)))* abs(ld(i)).LT.gaptol )
466  $ THEN
467  z( i+1 ) = zero
468  isuppz( 2 ) = i
469  GO TO 280
470  END IF
471  ztz = ztz + dble( z( i+1 )*z( i+1 ) )
472  270 CONTINUE
473  280 CONTINUE
474  END IF
475 *
476 * Compute quantities for convergence test
477 *
478  tmp = one / ztz
479  nrminv = sqrt( tmp )
480  resid = abs( mingma )*nrminv
481  rqcorr = mingma*tmp
482 *
483 *
484  RETURN
485 *
486 * End of ZLAR1V
487 *
488  END
subroutine zlar1v(N, B1, BN, LAMBDA, D, L, LD, LLD, PIVMIN, GAPTOL, Z, WANTNC, NEGCNT, ZTZ, MINGMA, R, ISUPPZ, NRMINV, RESID, RQCORR, WORK)
ZLAR1V computes the (scaled) r-th column of the inverse of the submatrix in rows b1 through bn of the...
Definition: zlar1v.f:232