|
7034
|
1 SUBROUTINE ZLAQR3( WANTT, WANTZ, N, KTOP, KBOT, NW, H, LDH, ILOZ, |
|
|
2 $ IHIZ, Z, LDZ, NS, ND, SH, V, LDV, NH, T, LDT, |
|
|
3 $ NV, WV, LDWV, WORK, LWORK ) |
|
|
4 * |
|
|
5 * -- LAPACK auxiliary routine (version 3.1) -- |
|
|
6 * Univ. of Tennessee, Univ. of California Berkeley and NAG Ltd.. |
|
|
7 * November 2006 |
|
|
8 * |
|
|
9 * .. Scalar Arguments .. |
|
|
10 INTEGER IHIZ, ILOZ, KBOT, KTOP, LDH, LDT, LDV, LDWV, |
|
|
11 $ LDZ, LWORK, N, ND, NH, NS, NV, NW |
|
|
12 LOGICAL WANTT, WANTZ |
|
|
13 * .. |
|
|
14 * .. Array Arguments .. |
|
|
15 COMPLEX*16 H( LDH, * ), SH( * ), T( LDT, * ), V( LDV, * ), |
|
|
16 $ WORK( * ), WV( LDWV, * ), Z( LDZ, * ) |
|
|
17 * .. |
|
|
18 * |
|
|
19 * ****************************************************************** |
|
|
20 * Aggressive early deflation: |
|
|
21 * |
|
|
22 * This subroutine accepts as input an upper Hessenberg matrix |
|
|
23 * H and performs an unitary similarity transformation |
|
|
24 * designed to detect and deflate fully converged eigenvalues from |
|
|
25 * a trailing principal submatrix. On output H has been over- |
|
|
26 * written by a new Hessenberg matrix that is a perturbation of |
|
|
27 * an unitary similarity transformation of H. It is to be |
|
|
28 * hoped that the final version of H has many zero subdiagonal |
|
|
29 * entries. |
|
|
30 * |
|
|
31 * ****************************************************************** |
|
|
32 * WANTT (input) LOGICAL |
|
|
33 * If .TRUE., then the Hessenberg matrix H is fully updated |
|
|
34 * so that the triangular Schur factor may be |
|
|
35 * computed (in cooperation with the calling subroutine). |
|
|
36 * If .FALSE., then only enough of H is updated to preserve |
|
|
37 * the eigenvalues. |
|
|
38 * |
|
|
39 * WANTZ (input) LOGICAL |
|
|
40 * If .TRUE., then the unitary matrix Z is updated so |
|
|
41 * so that the unitary Schur factor may be computed |
|
|
42 * (in cooperation with the calling subroutine). |
|
|
43 * If .FALSE., then Z is not referenced. |
|
|
44 * |
|
|
45 * N (input) INTEGER |
|
|
46 * The order of the matrix H and (if WANTZ is .TRUE.) the |
|
|
47 * order of the unitary matrix Z. |
|
|
48 * |
|
|
49 * KTOP (input) INTEGER |
|
|
50 * It is assumed that either KTOP = 1 or H(KTOP,KTOP-1)=0. |
|
|
51 * KBOT and KTOP together determine an isolated block |
|
|
52 * along the diagonal of the Hessenberg matrix. |
|
|
53 * |
|
|
54 * KBOT (input) INTEGER |
|
|
55 * It is assumed without a check that either |
|
|
56 * KBOT = N or H(KBOT+1,KBOT)=0. KBOT and KTOP together |
|
|
57 * determine an isolated block along the diagonal of the |
|
|
58 * Hessenberg matrix. |
|
|
59 * |
|
|
60 * NW (input) INTEGER |
|
|
61 * Deflation window size. 1 .LE. NW .LE. (KBOT-KTOP+1). |
|
|
62 * |
|
|
63 * H (input/output) COMPLEX*16 array, dimension (LDH,N) |
|
|
64 * On input the initial N-by-N section of H stores the |
|
|
65 * Hessenberg matrix undergoing aggressive early deflation. |
|
|
66 * On output H has been transformed by a unitary |
|
|
67 * similarity transformation, perturbed, and the returned |
|
|
68 * to Hessenberg form that (it is to be hoped) has some |
|
|
69 * zero subdiagonal entries. |
|
|
70 * |
|
|
71 * LDH (input) integer |
|
|
72 * Leading dimension of H just as declared in the calling |
|
|
73 * subroutine. N .LE. LDH |
|
|
74 * |
|
|
75 * ILOZ (input) INTEGER |
|
|
76 * IHIZ (input) INTEGER |
|
|
77 * Specify the rows of Z to which transformations must be |
|
|
78 * applied if WANTZ is .TRUE.. 1 .LE. ILOZ .LE. IHIZ .LE. N. |
|
|
79 * |
|
|
80 * Z (input/output) COMPLEX*16 array, dimension (LDZ,IHI) |
|
|
81 * IF WANTZ is .TRUE., then on output, the unitary |
|
|
82 * similarity transformation mentioned above has been |
|
|
83 * accumulated into Z(ILOZ:IHIZ,ILO:IHI) from the right. |
|
|
84 * If WANTZ is .FALSE., then Z is unreferenced. |
|
|
85 * |
|
|
86 * LDZ (input) integer |
|
|
87 * The leading dimension of Z just as declared in the |
|
|
88 * calling subroutine. 1 .LE. LDZ. |
|
|
89 * |
|
|
90 * NS (output) integer |
|
|
91 * The number of unconverged (ie approximate) eigenvalues |
|
|
92 * returned in SR and SI that may be used as shifts by the |
|
|
93 * calling subroutine. |
|
|
94 * |
|
|
95 * ND (output) integer |
|
|
96 * The number of converged eigenvalues uncovered by this |
|
|
97 * subroutine. |
|
|
98 * |
|
|
99 * SH (output) COMPLEX*16 array, dimension KBOT |
|
|
100 * On output, approximate eigenvalues that may |
|
|
101 * be used for shifts are stored in SH(KBOT-ND-NS+1) |
|
|
102 * through SR(KBOT-ND). Converged eigenvalues are |
|
|
103 * stored in SH(KBOT-ND+1) through SH(KBOT). |
|
|
104 * |
|
|
105 * V (workspace) COMPLEX*16 array, dimension (LDV,NW) |
|
|
106 * An NW-by-NW work array. |
|
|
107 * |
|
|
108 * LDV (input) integer scalar |
|
|
109 * The leading dimension of V just as declared in the |
|
|
110 * calling subroutine. NW .LE. LDV |
|
|
111 * |
|
|
112 * NH (input) integer scalar |
|
|
113 * The number of columns of T. NH.GE.NW. |
|
|
114 * |
|
|
115 * T (workspace) COMPLEX*16 array, dimension (LDT,NW) |
|
|
116 * |
|
|
117 * LDT (input) integer |
|
|
118 * The leading dimension of T just as declared in the |
|
|
119 * calling subroutine. NW .LE. LDT |
|
|
120 * |
|
|
121 * NV (input) integer |
|
|
122 * The number of rows of work array WV available for |
|
|
123 * workspace. NV.GE.NW. |
|
|
124 * |
|
|
125 * WV (workspace) COMPLEX*16 array, dimension (LDWV,NW) |
|
|
126 * |
|
|
127 * LDWV (input) integer |
|
|
128 * The leading dimension of W just as declared in the |
|
|
129 * calling subroutine. NW .LE. LDV |
|
|
130 * |
|
|
131 * WORK (workspace) COMPLEX*16 array, dimension LWORK. |
|
|
132 * On exit, WORK(1) is set to an estimate of the optimal value |
|
|
133 * of LWORK for the given values of N, NW, KTOP and KBOT. |
|
|
134 * |
|
|
135 * LWORK (input) integer |
|
|
136 * The dimension of the work array WORK. LWORK = 2*NW |
|
|
137 * suffices, but greater efficiency may result from larger |
|
|
138 * values of LWORK. |
|
|
139 * |
|
|
140 * If LWORK = -1, then a workspace query is assumed; ZLAQR3 |
|
|
141 * only estimates the optimal workspace size for the given |
|
|
142 * values of N, NW, KTOP and KBOT. The estimate is returned |
|
|
143 * in WORK(1). No error message related to LWORK is issued |
|
|
144 * by XERBLA. Neither H nor Z are accessed. |
|
|
145 * |
|
|
146 * ================================================================ |
|
|
147 * Based on contributions by |
|
|
148 * Karen Braman and Ralph Byers, Department of Mathematics, |
|
|
149 * University of Kansas, USA |
|
|
150 * |
|
|
151 * ================================================================== |
|
|
152 * .. Parameters .. |
|
|
153 COMPLEX*16 ZERO, ONE |
|
|
154 PARAMETER ( ZERO = ( 0.0d0, 0.0d0 ), |
|
|
155 $ ONE = ( 1.0d0, 0.0d0 ) ) |
|
|
156 DOUBLE PRECISION RZERO, RONE |
|
|
157 PARAMETER ( RZERO = 0.0d0, RONE = 1.0d0 ) |
|
|
158 * .. |
|
|
159 * .. Local Scalars .. |
|
|
160 COMPLEX*16 BETA, CDUM, S, TAU |
|
|
161 DOUBLE PRECISION FOO, SAFMAX, SAFMIN, SMLNUM, ULP |
|
|
162 INTEGER I, IFST, ILST, INFO, INFQR, J, JW, KCOL, KLN, |
|
|
163 $ KNT, KROW, KWTOP, LTOP, LWK1, LWK2, LWK3, |
|
|
164 $ LWKOPT, NMIN |
|
|
165 * .. |
|
|
166 * .. External Functions .. |
|
|
167 DOUBLE PRECISION DLAMCH |
|
|
168 INTEGER ILAENV |
|
|
169 EXTERNAL DLAMCH, ILAENV |
|
|
170 * .. |
|
|
171 * .. External Subroutines .. |
|
|
172 EXTERNAL DLABAD, ZCOPY, ZGEHRD, ZGEMM, ZLACPY, ZLAHQR, |
|
|
173 $ ZLAQR4, ZLARF, ZLARFG, ZLASET, ZTREXC, ZUNGHR |
|
|
174 * .. |
|
|
175 * .. Intrinsic Functions .. |
|
|
176 INTRINSIC ABS, DBLE, DCMPLX, DCONJG, DIMAG, INT, MAX, MIN |
|
|
177 * .. |
|
|
178 * .. Statement Functions .. |
|
|
179 DOUBLE PRECISION CABS1 |
|
|
180 * .. |
|
|
181 * .. Statement Function definitions .. |
|
|
182 CABS1( CDUM ) = ABS( DBLE( CDUM ) ) + ABS( DIMAG( CDUM ) ) |
|
|
183 * .. |
|
|
184 * .. Executable Statements .. |
|
|
185 * |
|
|
186 * ==== Estimate optimal workspace. ==== |
|
|
187 * |
|
|
188 JW = MIN( NW, KBOT-KTOP+1 ) |
|
|
189 IF( JW.LE.2 ) THEN |
|
|
190 LWKOPT = 1 |
|
|
191 ELSE |
|
|
192 * |
|
|
193 * ==== Workspace query call to ZGEHRD ==== |
|
|
194 * |
|
|
195 CALL ZGEHRD( JW, 1, JW-1, T, LDT, WORK, WORK, -1, INFO ) |
|
|
196 LWK1 = INT( WORK( 1 ) ) |
|
|
197 * |
|
|
198 * ==== Workspace query call to ZUNGHR ==== |
|
|
199 * |
|
|
200 CALL ZUNGHR( JW, 1, JW-1, T, LDT, WORK, WORK, -1, INFO ) |
|
|
201 LWK2 = INT( WORK( 1 ) ) |
|
|
202 * |
|
|
203 * ==== Workspace query call to ZLAQR4 ==== |
|
|
204 * |
|
|
205 CALL ZLAQR4( .true., .true., JW, 1, JW, T, LDT, SH, 1, JW, V, |
|
|
206 $ LDV, WORK, -1, INFQR ) |
|
|
207 LWK3 = INT( WORK( 1 ) ) |
|
|
208 * |
|
|
209 * ==== Optimal workspace ==== |
|
|
210 * |
|
|
211 LWKOPT = MAX( JW+MAX( LWK1, LWK2 ), LWK3 ) |
|
|
212 END IF |
|
|
213 * |
|
|
214 * ==== Quick return in case of workspace query. ==== |
|
|
215 * |
|
|
216 IF( LWORK.EQ.-1 ) THEN |
|
|
217 WORK( 1 ) = DCMPLX( LWKOPT, 0 ) |
|
|
218 RETURN |
|
|
219 END IF |
|
|
220 * |
|
|
221 * ==== Nothing to do ... |
|
|
222 * ... for an empty active block ... ==== |
|
|
223 NS = 0 |
|
|
224 ND = 0 |
|
|
225 IF( KTOP.GT.KBOT ) |
|
|
226 $ RETURN |
|
|
227 * ... nor for an empty deflation window. ==== |
|
|
228 IF( NW.LT.1 ) |
|
|
229 $ RETURN |
|
|
230 * |
|
|
231 * ==== Machine constants ==== |
|
|
232 * |
|
|
233 SAFMIN = DLAMCH( 'SAFE MINIMUM' ) |
|
|
234 SAFMAX = RONE / SAFMIN |
|
|
235 CALL DLABAD( SAFMIN, SAFMAX ) |
|
|
236 ULP = DLAMCH( 'PRECISION' ) |
|
|
237 SMLNUM = SAFMIN*( DBLE( N ) / ULP ) |
|
|
238 * |
|
|
239 * ==== Setup deflation window ==== |
|
|
240 * |
|
|
241 JW = MIN( NW, KBOT-KTOP+1 ) |
|
|
242 KWTOP = KBOT - JW + 1 |
|
|
243 IF( KWTOP.EQ.KTOP ) THEN |
|
|
244 S = ZERO |
|
|
245 ELSE |
|
|
246 S = H( KWTOP, KWTOP-1 ) |
|
|
247 END IF |
|
|
248 * |
|
|
249 IF( KBOT.EQ.KWTOP ) THEN |
|
|
250 * |
|
|
251 * ==== 1-by-1 deflation window: not much to do ==== |
|
|
252 * |
|
|
253 SH( KWTOP ) = H( KWTOP, KWTOP ) |
|
|
254 NS = 1 |
|
|
255 ND = 0 |
|
|
256 IF( CABS1( S ).LE.MAX( SMLNUM, ULP*CABS1( H( KWTOP, |
|
|
257 $ KWTOP ) ) ) ) THEN |
|
|
258 |
|
|
259 NS = 0 |
|
|
260 ND = 1 |
|
|
261 IF( KWTOP.GT.KTOP ) |
|
|
262 $ H( KWTOP, KWTOP-1 ) = ZERO |
|
|
263 END IF |
|
|
264 RETURN |
|
|
265 END IF |
|
|
266 * |
|
|
267 * ==== Convert to spike-triangular form. (In case of a |
|
|
268 * . rare QR failure, this routine continues to do |
|
|
269 * . aggressive early deflation using that part of |
|
|
270 * . the deflation window that converged using INFQR |
|
|
271 * . here and there to keep track.) ==== |
|
|
272 * |
|
|
273 CALL ZLACPY( 'U', JW, JW, H( KWTOP, KWTOP ), LDH, T, LDT ) |
|
|
274 CALL ZCOPY( JW-1, H( KWTOP+1, KWTOP ), LDH+1, T( 2, 1 ), LDT+1 ) |
|
|
275 * |
|
|
276 CALL ZLASET( 'A', JW, JW, ZERO, ONE, V, LDV ) |
|
|
277 NMIN = ILAENV( 12, 'ZLAQR3', 'SV', JW, 1, JW, LWORK ) |
|
|
278 IF( JW.GT.NMIN ) THEN |
|
|
279 CALL ZLAQR4( .true., .true., JW, 1, JW, T, LDT, SH( KWTOP ), 1, |
|
|
280 $ JW, V, LDV, WORK, LWORK, INFQR ) |
|
|
281 ELSE |
|
|
282 CALL ZLAHQR( .true., .true., JW, 1, JW, T, LDT, SH( KWTOP ), 1, |
|
|
283 $ JW, V, LDV, INFQR ) |
|
|
284 END IF |
|
|
285 * |
|
|
286 * ==== Deflation detection loop ==== |
|
|
287 * |
|
|
288 NS = JW |
|
|
289 ILST = INFQR + 1 |
|
|
290 DO 10 KNT = INFQR + 1, JW |
|
|
291 * |
|
|
292 * ==== Small spike tip deflation test ==== |
|
|
293 * |
|
|
294 FOO = CABS1( T( NS, NS ) ) |
|
|
295 IF( FOO.EQ.RZERO ) |
|
|
296 $ FOO = CABS1( S ) |
|
|
297 IF( CABS1( S )*CABS1( V( 1, NS ) ).LE.MAX( SMLNUM, ULP*FOO ) ) |
|
|
298 $ THEN |
|
|
299 * |
|
|
300 * ==== One more converged eigenvalue ==== |
|
|
301 * |
|
|
302 NS = NS - 1 |
|
|
303 ELSE |
|
|
304 * |
|
|
305 * ==== One undflatable eigenvalue. Move it up out of the |
|
|
306 * . way. (ZTREXC can not fail in this case.) ==== |
|
|
307 * |
|
|
308 IFST = NS |
|
|
309 CALL ZTREXC( 'V', JW, T, LDT, V, LDV, IFST, ILST, INFO ) |
|
|
310 ILST = ILST + 1 |
|
|
311 END IF |
|
|
312 10 CONTINUE |
|
|
313 * |
|
|
314 * ==== Return to Hessenberg form ==== |
|
|
315 * |
|
|
316 IF( NS.EQ.0 ) |
|
|
317 $ S = ZERO |
|
|
318 * |
|
|
319 IF( NS.LT.JW ) THEN |
|
|
320 * |
|
|
321 * ==== sorting the diagonal of T improves accuracy for |
|
|
322 * . graded matrices. ==== |
|
|
323 * |
|
|
324 DO 30 I = INFQR + 1, NS |
|
|
325 IFST = I |
|
|
326 DO 20 J = I + 1, NS |
|
|
327 IF( CABS1( T( J, J ) ).GT.CABS1( T( IFST, IFST ) ) ) |
|
|
328 $ IFST = J |
|
|
329 20 CONTINUE |
|
|
330 ILST = I |
|
|
331 IF( IFST.NE.ILST ) |
|
|
332 $ CALL ZTREXC( 'V', JW, T, LDT, V, LDV, IFST, ILST, INFO ) |
|
|
333 30 CONTINUE |
|
|
334 END IF |
|
|
335 * |
|
|
336 * ==== Restore shift/eigenvalue array from T ==== |
|
|
337 * |
|
|
338 DO 40 I = INFQR + 1, JW |
|
|
339 SH( KWTOP+I-1 ) = T( I, I ) |
|
|
340 40 CONTINUE |
|
|
341 * |
|
|
342 * |
|
|
343 IF( NS.LT.JW .OR. S.EQ.ZERO ) THEN |
|
|
344 IF( NS.GT.1 .AND. S.NE.ZERO ) THEN |
|
|
345 * |
|
|
346 * ==== Reflect spike back into lower triangle ==== |
|
|
347 * |
|
|
348 CALL ZCOPY( NS, V, LDV, WORK, 1 ) |
|
|
349 DO 50 I = 1, NS |
|
|
350 WORK( I ) = DCONJG( WORK( I ) ) |
|
|
351 50 CONTINUE |
|
|
352 BETA = WORK( 1 ) |
|
|
353 CALL ZLARFG( NS, BETA, WORK( 2 ), 1, TAU ) |
|
|
354 WORK( 1 ) = ONE |
|
|
355 * |
|
|
356 CALL ZLASET( 'L', JW-2, JW-2, ZERO, ZERO, T( 3, 1 ), LDT ) |
|
|
357 * |
|
|
358 CALL ZLARF( 'L', NS, JW, WORK, 1, DCONJG( TAU ), T, LDT, |
|
|
359 $ WORK( JW+1 ) ) |
|
|
360 CALL ZLARF( 'R', NS, NS, WORK, 1, TAU, T, LDT, |
|
|
361 $ WORK( JW+1 ) ) |
|
|
362 CALL ZLARF( 'R', JW, NS, WORK, 1, TAU, V, LDV, |
|
|
363 $ WORK( JW+1 ) ) |
|
|
364 * |
|
|
365 CALL ZGEHRD( JW, 1, NS, T, LDT, WORK, WORK( JW+1 ), |
|
|
366 $ LWORK-JW, INFO ) |
|
|
367 END IF |
|
|
368 * |
|
|
369 * ==== Copy updated reduced window into place ==== |
|
|
370 * |
|
|
371 IF( KWTOP.GT.1 ) |
|
|
372 $ H( KWTOP, KWTOP-1 ) = S*DCONJG( V( 1, 1 ) ) |
|
|
373 CALL ZLACPY( 'U', JW, JW, T, LDT, H( KWTOP, KWTOP ), LDH ) |
|
|
374 CALL ZCOPY( JW-1, T( 2, 1 ), LDT+1, H( KWTOP+1, KWTOP ), |
|
|
375 $ LDH+1 ) |
|
|
376 * |
|
|
377 * ==== Accumulate orthogonal matrix in order update |
|
|
378 * . H and Z, if requested. (A modified version |
|
|
379 * . of ZUNGHR that accumulates block Householder |
|
|
380 * . transformations into V directly might be |
|
|
381 * . marginally more efficient than the following.) ==== |
|
|
382 * |
|
|
383 IF( NS.GT.1 .AND. S.NE.ZERO ) THEN |
|
|
384 CALL ZUNGHR( JW, 1, NS, T, LDT, WORK, WORK( JW+1 ), |
|
|
385 $ LWORK-JW, INFO ) |
|
|
386 CALL ZGEMM( 'N', 'N', JW, NS, NS, ONE, V, LDV, T, LDT, ZERO, |
|
|
387 $ WV, LDWV ) |
|
|
388 CALL ZLACPY( 'A', JW, NS, WV, LDWV, V, LDV ) |
|
|
389 END IF |
|
|
390 * |
|
|
391 * ==== Update vertical slab in H ==== |
|
|
392 * |
|
|
393 IF( WANTT ) THEN |
|
|
394 LTOP = 1 |
|
|
395 ELSE |
|
|
396 LTOP = KTOP |
|
|
397 END IF |
|
|
398 DO 60 KROW = LTOP, KWTOP - 1, NV |
|
|
399 KLN = MIN( NV, KWTOP-KROW ) |
|
|
400 CALL ZGEMM( 'N', 'N', KLN, JW, JW, ONE, H( KROW, KWTOP ), |
|
|
401 $ LDH, V, LDV, ZERO, WV, LDWV ) |
|
|
402 CALL ZLACPY( 'A', KLN, JW, WV, LDWV, H( KROW, KWTOP ), LDH ) |
|
|
403 60 CONTINUE |
|
|
404 * |
|
|
405 * ==== Update horizontal slab in H ==== |
|
|
406 * |
|
|
407 IF( WANTT ) THEN |
|
|
408 DO 70 KCOL = KBOT + 1, N, NH |
|
|
409 KLN = MIN( NH, N-KCOL+1 ) |
|
|
410 CALL ZGEMM( 'C', 'N', JW, KLN, JW, ONE, V, LDV, |
|
|
411 $ H( KWTOP, KCOL ), LDH, ZERO, T, LDT ) |
|
|
412 CALL ZLACPY( 'A', JW, KLN, T, LDT, H( KWTOP, KCOL ), |
|
|
413 $ LDH ) |
|
|
414 70 CONTINUE |
|
|
415 END IF |
|
|
416 * |
|
|
417 * ==== Update vertical slab in Z ==== |
|
|
418 * |
|
|
419 IF( WANTZ ) THEN |
|
|
420 DO 80 KROW = ILOZ, IHIZ, NV |
|
|
421 KLN = MIN( NV, IHIZ-KROW+1 ) |
|
|
422 CALL ZGEMM( 'N', 'N', KLN, JW, JW, ONE, Z( KROW, KWTOP ), |
|
|
423 $ LDZ, V, LDV, ZERO, WV, LDWV ) |
|
|
424 CALL ZLACPY( 'A', KLN, JW, WV, LDWV, Z( KROW, KWTOP ), |
|
|
425 $ LDZ ) |
|
|
426 80 CONTINUE |
|
|
427 END IF |
|
|
428 END IF |
|
|
429 * |
|
|
430 * ==== Return the number of deflations ... ==== |
|
|
431 * |
|
|
432 ND = JW - NS |
|
|
433 * |
|
|
434 * ==== ... and the number of shifts. (Subtracting |
|
|
435 * . INFQR from the spike length takes care |
|
|
436 * . of the case of a rare QR failure while |
|
|
437 * . calculating eigenvalues of the deflation |
|
|
438 * . window.) ==== |
|
|
439 * |
|
|
440 NS = NS - INFQR |
|
|
441 * |
|
|
442 * ==== Return optimal workspace. ==== |
|
|
443 * |
|
|
444 WORK( 1 ) = DCMPLX( LWKOPT, 0 ) |
|
|
445 * |
|
|
446 * ==== End of ZLAQR3 ==== |
|
|
447 * |
|
|
448 END |
