LAPACK 3.12.0
LAPACK: Linear Algebra PACKage
Loading...
Searching...
No Matches
zla_porfsx_extended.f
Go to the documentation of this file.
1*> \brief \b ZLA_PORFSX_EXTENDED improves the computed solution to a system of linear equations for symmetric or Hermitian positive-definite matrices by performing extra-precise iterative refinement and provides error bounds and backward error estimates for the solution.
2*
3* =========== DOCUMENTATION ===========
4*
5* Online html documentation available at
6* http://www.netlib.org/lapack/explore-html/
7*
8*> \htmlonly
9*> Download ZLA_PORFSX_EXTENDED + dependencies
10*> <a href="http://www.netlib.org/cgi-bin/netlibfiles.tgz?format=tgz&filename=/lapack/lapack_routine/zla_porfsx_extended.f">
11*> [TGZ]</a>
12*> <a href="http://www.netlib.org/cgi-bin/netlibfiles.zip?format=zip&filename=/lapack/lapack_routine/zla_porfsx_extended.f">
13*> [ZIP]</a>
14*> <a href="http://www.netlib.org/cgi-bin/netlibfiles.txt?format=txt&filename=/lapack/lapack_routine/zla_porfsx_extended.f">
15*> [TXT]</a>
16*> \endhtmlonly
17*
18* Definition:
19* ===========
20*
21* SUBROUTINE ZLA_PORFSX_EXTENDED( PREC_TYPE, UPLO, N, NRHS, A, LDA,
22* AF, LDAF, COLEQU, C, B, LDB, Y,
23* LDY, BERR_OUT, N_NORMS,
24* ERR_BNDS_NORM, ERR_BNDS_COMP, RES,
25* AYB, DY, Y_TAIL, RCOND, ITHRESH,
26* RTHRESH, DZ_UB, IGNORE_CWISE,
27* INFO )
28*
29* .. Scalar Arguments ..
30* INTEGER INFO, LDA, LDAF, LDB, LDY, N, NRHS, PREC_TYPE,
31* $ N_NORMS, ITHRESH
32* CHARACTER UPLO
33* LOGICAL COLEQU, IGNORE_CWISE
34* DOUBLE PRECISION RTHRESH, DZ_UB
35* ..
36* .. Array Arguments ..
37* COMPLEX*16 A( LDA, * ), AF( LDAF, * ), B( LDB, * ),
38* $ Y( LDY, * ), RES( * ), DY( * ), Y_TAIL( * )
39* DOUBLE PRECISION C( * ), AYB( * ), RCOND, BERR_OUT( * ),
40* $ ERR_BNDS_NORM( NRHS, * ),
41* $ ERR_BNDS_COMP( NRHS, * )
42* ..
43*
44*
45*> \par Purpose:
46* =============
47*>
48*> \verbatim
49*>
50*> ZLA_PORFSX_EXTENDED improves the computed solution to a system of
51*> linear equations by performing extra-precise iterative refinement
52*> and provides error bounds and backward error estimates for the solution.
53*> This subroutine is called by ZPORFSX to perform iterative refinement.
54*> In addition to normwise error bound, the code provides maximum
55*> componentwise error bound if possible. See comments for ERR_BNDS_NORM
56*> and ERR_BNDS_COMP for details of the error bounds. Note that this
57*> subroutine is only responsible for setting the second fields of
58*> ERR_BNDS_NORM and ERR_BNDS_COMP.
59*> \endverbatim
60*
61* Arguments:
62* ==========
63*
64*> \param[in] PREC_TYPE
65*> \verbatim
66*> PREC_TYPE is INTEGER
67*> Specifies the intermediate precision to be used in refinement.
68*> The value is defined by ILAPREC(P) where P is a CHARACTER and P
69*> = 'S': Single
70*> = 'D': Double
71*> = 'I': Indigenous
72*> = 'X' or 'E': Extra
73*> \endverbatim
74*>
75*> \param[in] UPLO
76*> \verbatim
77*> UPLO is CHARACTER*1
78*> = 'U': Upper triangle of A is stored;
79*> = 'L': Lower triangle of A is stored.
80*> \endverbatim
81*>
82*> \param[in] N
83*> \verbatim
84*> N is INTEGER
85*> The number of linear equations, i.e., the order of the
86*> matrix A. N >= 0.
87*> \endverbatim
88*>
89*> \param[in] NRHS
90*> \verbatim
91*> NRHS is INTEGER
92*> The number of right-hand-sides, i.e., the number of columns of the
93*> matrix B.
94*> \endverbatim
95*>
96*> \param[in] A
97*> \verbatim
98*> A is COMPLEX*16 array, dimension (LDA,N)
99*> On entry, the N-by-N matrix A.
100*> \endverbatim
101*>
102*> \param[in] LDA
103*> \verbatim
104*> LDA is INTEGER
105*> The leading dimension of the array A. LDA >= max(1,N).
106*> \endverbatim
107*>
108*> \param[in] AF
109*> \verbatim
110*> AF is COMPLEX*16 array, dimension (LDAF,N)
111*> The triangular factor U or L from the Cholesky factorization
112*> A = U**T*U or A = L*L**T, as computed by ZPOTRF.
113*> \endverbatim
114*>
115*> \param[in] LDAF
116*> \verbatim
117*> LDAF is INTEGER
118*> The leading dimension of the array AF. LDAF >= max(1,N).
119*> \endverbatim
120*>
121*> \param[in] COLEQU
122*> \verbatim
123*> COLEQU is LOGICAL
124*> If .TRUE. then column equilibration was done to A before calling
125*> this routine. This is needed to compute the solution and error
126*> bounds correctly.
127*> \endverbatim
128*>
129*> \param[in] C
130*> \verbatim
131*> C is DOUBLE PRECISION array, dimension (N)
132*> The column scale factors for A. If COLEQU = .FALSE., C
133*> is not accessed. If C is input, each element of C should be a power
134*> of the radix to ensure a reliable solution and error estimates.
135*> Scaling by powers of the radix does not cause rounding errors unless
136*> the result underflows or overflows. Rounding errors during scaling
137*> lead to refining with a matrix that is not equivalent to the
138*> input matrix, producing error estimates that may not be
139*> reliable.
140*> \endverbatim
141*>
142*> \param[in] B
143*> \verbatim
144*> B is COMPLEX*16 array, dimension (LDB,NRHS)
145*> The right-hand-side matrix B.
146*> \endverbatim
147*>
148*> \param[in] LDB
149*> \verbatim
150*> LDB is INTEGER
151*> The leading dimension of the array B. LDB >= max(1,N).
152*> \endverbatim
153*>
154*> \param[in,out] Y
155*> \verbatim
156*> Y is COMPLEX*16 array, dimension (LDY,NRHS)
157*> On entry, the solution matrix X, as computed by ZPOTRS.
158*> On exit, the improved solution matrix Y.
159*> \endverbatim
160*>
161*> \param[in] LDY
162*> \verbatim
163*> LDY is INTEGER
164*> The leading dimension of the array Y. LDY >= max(1,N).
165*> \endverbatim
166*>
167*> \param[out] BERR_OUT
168*> \verbatim
169*> BERR_OUT is DOUBLE PRECISION array, dimension (NRHS)
170*> On exit, BERR_OUT(j) contains the componentwise relative backward
171*> error for right-hand-side j from the formula
172*> max(i) ( abs(RES(i)) / ( abs(op(A_s))*abs(Y) + abs(B_s) )(i) )
173*> where abs(Z) is the componentwise absolute value of the matrix
174*> or vector Z. This is computed by ZLA_LIN_BERR.
175*> \endverbatim
176*>
177*> \param[in] N_NORMS
178*> \verbatim
179*> N_NORMS is INTEGER
180*> Determines which error bounds to return (see ERR_BNDS_NORM
181*> and ERR_BNDS_COMP).
182*> If N_NORMS >= 1 return normwise error bounds.
183*> If N_NORMS >= 2 return componentwise error bounds.
184*> \endverbatim
185*>
186*> \param[in,out] ERR_BNDS_NORM
187*> \verbatim
188*> ERR_BNDS_NORM is DOUBLE PRECISION array, dimension (NRHS, N_ERR_BNDS)
189*> For each right-hand side, this array contains information about
190*> various error bounds and condition numbers corresponding to the
191*> normwise relative error, which is defined as follows:
192*>
193*> Normwise relative error in the ith solution vector:
194*> max_j (abs(XTRUE(j,i) - X(j,i)))
195*> ------------------------------
196*> max_j abs(X(j,i))
197*>
198*> The array is indexed by the type of error information as described
199*> below. There currently are up to three pieces of information
200*> returned.
201*>
202*> The first index in ERR_BNDS_NORM(i,:) corresponds to the ith
203*> right-hand side.
204*>
205*> The second index in ERR_BNDS_NORM(:,err) contains the following
206*> three fields:
207*> err = 1 "Trust/don't trust" boolean. Trust the answer if the
208*> reciprocal condition number is less than the threshold
209*> sqrt(n) * slamch('Epsilon').
210*>
211*> err = 2 "Guaranteed" error bound: The estimated forward error,
212*> almost certainly within a factor of 10 of the true error
213*> so long as the next entry is greater than the threshold
214*> sqrt(n) * slamch('Epsilon'). This error bound should only
215*> be trusted if the previous boolean is true.
216*>
217*> err = 3 Reciprocal condition number: Estimated normwise
218*> reciprocal condition number. Compared with the threshold
219*> sqrt(n) * slamch('Epsilon') to determine if the error
220*> estimate is "guaranteed". These reciprocal condition
221*> numbers are 1 / (norm(Z^{-1},inf) * norm(Z,inf)) for some
222*> appropriately scaled matrix Z.
223*> Let Z = S*A, where S scales each row by a power of the
224*> radix so all absolute row sums of Z are approximately 1.
225*>
226*> This subroutine is only responsible for setting the second field
227*> above.
228*> See Lapack Working Note 165 for further details and extra
229*> cautions.
230*> \endverbatim
231*>
232*> \param[in,out] ERR_BNDS_COMP
233*> \verbatim
234*> ERR_BNDS_COMP is DOUBLE PRECISION array, dimension (NRHS, N_ERR_BNDS)
235*> For each right-hand side, this array contains information about
236*> various error bounds and condition numbers corresponding to the
237*> componentwise relative error, which is defined as follows:
238*>
239*> Componentwise relative error in the ith solution vector:
240*> abs(XTRUE(j,i) - X(j,i))
241*> max_j ----------------------
242*> abs(X(j,i))
243*>
244*> The array is indexed by the right-hand side i (on which the
245*> componentwise relative error depends), and the type of error
246*> information as described below. There currently are up to three
247*> pieces of information returned for each right-hand side. If
248*> componentwise accuracy is not requested (PARAMS(3) = 0.0), then
249*> ERR_BNDS_COMP is not accessed. If N_ERR_BNDS < 3, then at most
250*> the first (:,N_ERR_BNDS) entries are returned.
251*>
252*> The first index in ERR_BNDS_COMP(i,:) corresponds to the ith
253*> right-hand side.
254*>
255*> The second index in ERR_BNDS_COMP(:,err) contains the following
256*> three fields:
257*> err = 1 "Trust/don't trust" boolean. Trust the answer if the
258*> reciprocal condition number is less than the threshold
259*> sqrt(n) * slamch('Epsilon').
260*>
261*> err = 2 "Guaranteed" error bound: The estimated forward error,
262*> almost certainly within a factor of 10 of the true error
263*> so long as the next entry is greater than the threshold
264*> sqrt(n) * slamch('Epsilon'). This error bound should only
265*> be trusted if the previous boolean is true.
266*>
267*> err = 3 Reciprocal condition number: Estimated componentwise
268*> reciprocal condition number. Compared with the threshold
269*> sqrt(n) * slamch('Epsilon') to determine if the error
270*> estimate is "guaranteed". These reciprocal condition
271*> numbers are 1 / (norm(Z^{-1},inf) * norm(Z,inf)) for some
272*> appropriately scaled matrix Z.
273*> Let Z = S*(A*diag(x)), where x is the solution for the
274*> current right-hand side and S scales each row of
275*> A*diag(x) by a power of the radix so all absolute row
276*> sums of Z are approximately 1.
277*>
278*> This subroutine is only responsible for setting the second field
279*> above.
280*> See Lapack Working Note 165 for further details and extra
281*> cautions.
282*> \endverbatim
283*>
284*> \param[in] RES
285*> \verbatim
286*> RES is COMPLEX*16 array, dimension (N)
287*> Workspace to hold the intermediate residual.
288*> \endverbatim
289*>
290*> \param[in] AYB
291*> \verbatim
292*> AYB is DOUBLE PRECISION array, dimension (N)
293*> Workspace.
294*> \endverbatim
295*>
296*> \param[in] DY
297*> \verbatim
298*> DY is COMPLEX*16 PRECISION array, dimension (N)
299*> Workspace to hold the intermediate solution.
300*> \endverbatim
301*>
302*> \param[in] Y_TAIL
303*> \verbatim
304*> Y_TAIL is COMPLEX*16 array, dimension (N)
305*> Workspace to hold the trailing bits of the intermediate solution.
306*> \endverbatim
307*>
308*> \param[in] RCOND
309*> \verbatim
310*> RCOND is DOUBLE PRECISION
311*> Reciprocal scaled condition number. This is an estimate of the
312*> reciprocal Skeel condition number of the matrix A after
313*> equilibration (if done). If this is less than the machine
314*> precision (in particular, if it is zero), the matrix is singular
315*> to working precision. Note that the error may still be small even
316*> if this number is very small and the matrix appears ill-
317*> conditioned.
318*> \endverbatim
319*>
320*> \param[in] ITHRESH
321*> \verbatim
322*> ITHRESH is INTEGER
323*> The maximum number of residual computations allowed for
324*> refinement. The default is 10. For 'aggressive' set to 100 to
325*> permit convergence using approximate factorizations or
326*> factorizations other than LU. If the factorization uses a
327*> technique other than Gaussian elimination, the guarantees in
328*> ERR_BNDS_NORM and ERR_BNDS_COMP may no longer be trustworthy.
329*> \endverbatim
330*>
331*> \param[in] RTHRESH
332*> \verbatim
333*> RTHRESH is DOUBLE PRECISION
334*> Determines when to stop refinement if the error estimate stops
335*> decreasing. Refinement will stop when the next solution no longer
336*> satisfies norm(dx_{i+1}) < RTHRESH * norm(dx_i) where norm(Z) is
337*> the infinity norm of Z. RTHRESH satisfies 0 < RTHRESH <= 1. The
338*> default value is 0.5. For 'aggressive' set to 0.9 to permit
339*> convergence on extremely ill-conditioned matrices. See LAWN 165
340*> for more details.
341*> \endverbatim
342*>
343*> \param[in] DZ_UB
344*> \verbatim
345*> DZ_UB is DOUBLE PRECISION
346*> Determines when to start considering componentwise convergence.
347*> Componentwise convergence is only considered after each component
348*> of the solution Y is stable, which we define as the relative
349*> change in each component being less than DZ_UB. The default value
350*> is 0.25, requiring the first bit to be stable. See LAWN 165 for
351*> more details.
352*> \endverbatim
353*>
354*> \param[in] IGNORE_CWISE
355*> \verbatim
356*> IGNORE_CWISE is LOGICAL
357*> If .TRUE. then ignore componentwise convergence. Default value
358*> is .FALSE..
359*> \endverbatim
360*>
361*> \param[out] INFO
362*> \verbatim
363*> INFO is INTEGER
364*> = 0: Successful exit.
365*> < 0: if INFO = -i, the ith argument to ZPOTRS had an illegal
366*> value
367*> \endverbatim
368*
369* Authors:
370* ========
371*
372*> \author Univ. of Tennessee
373*> \author Univ. of California Berkeley
374*> \author Univ. of Colorado Denver
375*> \author NAG Ltd.
376*
377*> \ingroup la_porfsx_extended
378*
379* =====================================================================
380 SUBROUTINE zla_porfsx_extended( PREC_TYPE, UPLO, N, NRHS, A, LDA,
381 $ AF, LDAF, COLEQU, C, B, LDB, Y,
382 $ LDY, BERR_OUT, N_NORMS,
383 $ ERR_BNDS_NORM, ERR_BNDS_COMP, RES,
384 $ AYB, DY, Y_TAIL, RCOND, ITHRESH,
385 $ RTHRESH, DZ_UB, IGNORE_CWISE,
386 $ INFO )
387*
388* -- LAPACK computational routine --
389* -- LAPACK is a software package provided by Univ. of Tennessee, --
390* -- Univ. of California Berkeley, Univ. of Colorado Denver and NAG Ltd..--
391*
392* .. Scalar Arguments ..
393 INTEGER INFO, LDA, LDAF, LDB, LDY, N, NRHS, PREC_TYPE,
394 $ N_NORMS, ITHRESH
395 CHARACTER UPLO
396 LOGICAL COLEQU, IGNORE_CWISE
397 DOUBLE PRECISION RTHRESH, DZ_UB
398* ..
399* .. Array Arguments ..
400 COMPLEX*16 A( LDA, * ), AF( LDAF, * ), B( LDB, * ),
401 $ y( ldy, * ), res( * ), dy( * ), y_tail( * )
402 DOUBLE PRECISION C( * ), AYB( * ), RCOND, BERR_OUT( * ),
403 $ err_bnds_norm( nrhs, * ),
404 $ err_bnds_comp( nrhs, * )
405* ..
406*
407* =====================================================================
408*
409* .. Local Scalars ..
410 INTEGER UPLO2, CNT, I, J, X_STATE, Z_STATE,
411 $ Y_PREC_STATE
412 DOUBLE PRECISION YK, DYK, YMIN, NORMY, NORMX, NORMDX, DXRAT,
413 $ DZRAT, PREVNORMDX, PREV_DZ_Z, DXRATMAX,
414 $ DZRATMAX, DX_X, DZ_Z, FINAL_DX_X, FINAL_DZ_Z,
415 $ EPS, HUGEVAL, INCR_THRESH
416 LOGICAL INCR_PREC
417 COMPLEX*16 ZDUM
418* ..
419* .. Parameters ..
420 INTEGER UNSTABLE_STATE, WORKING_STATE, CONV_STATE,
421 $ NOPROG_STATE, BASE_RESIDUAL, EXTRA_RESIDUAL,
422 $ extra_y
423 parameter( unstable_state = 0, working_state = 1,
424 $ conv_state = 2, noprog_state = 3 )
425 parameter( base_residual = 0, extra_residual = 1,
426 $ extra_y = 2 )
427 INTEGER FINAL_NRM_ERR_I, FINAL_CMP_ERR_I, BERR_I
428 INTEGER RCOND_I, NRM_RCOND_I, NRM_ERR_I, CMP_RCOND_I
429 INTEGER CMP_ERR_I, PIV_GROWTH_I
430 PARAMETER ( FINAL_NRM_ERR_I = 1, final_cmp_err_i = 2,
431 $ berr_i = 3 )
432 parameter( rcond_i = 4, nrm_rcond_i = 5, nrm_err_i = 6 )
433 parameter( cmp_rcond_i = 7, cmp_err_i = 8,
434 $ piv_growth_i = 9 )
435 INTEGER LA_LINRX_ITREF_I, LA_LINRX_ITHRESH_I,
436 $ la_linrx_cwise_i
437 parameter( la_linrx_itref_i = 1,
438 $ la_linrx_ithresh_i = 2 )
439 parameter( la_linrx_cwise_i = 3 )
440 INTEGER LA_LINRX_TRUST_I, LA_LINRX_ERR_I,
441 $ la_linrx_rcond_i
442 parameter( la_linrx_trust_i = 1, la_linrx_err_i = 2 )
443 parameter( la_linrx_rcond_i = 3 )
444* ..
445* .. External Functions ..
446 LOGICAL LSAME
447 EXTERNAL ILAUPLO
448 INTEGER ILAUPLO
449* ..
450* .. External Subroutines ..
451 EXTERNAL zaxpy, zcopy, zpotrs, zhemv, blas_zhemv_x,
452 $ blas_zhemv2_x, zla_heamv, zla_wwaddw,
454 DOUBLE PRECISION DLAMCH
455* ..
456* .. Intrinsic Functions ..
457 INTRINSIC abs, dble, dimag, max, min
458* ..
459* .. Statement Functions ..
460 DOUBLE PRECISION CABS1
461* ..
462* .. Statement Function Definitions ..
463 cabs1( zdum ) = abs( dble( zdum ) ) + abs( dimag( zdum ) )
464* ..
465* .. Executable Statements ..
466*
467 IF (info.NE.0) RETURN
468 eps = dlamch( 'Epsilon' )
469 hugeval = dlamch( 'Overflow' )
470* Force HUGEVAL to Inf
471 hugeval = hugeval * hugeval
472* Using HUGEVAL may lead to spurious underflows.
473 incr_thresh = dble(n) * eps
474
475 IF (lsame(uplo, 'L')) THEN
476 uplo2 = ilauplo( 'L' )
477 ELSE
478 uplo2 = ilauplo( 'U' )
479 ENDIF
480
481 DO j = 1, nrhs
482 y_prec_state = extra_residual
483 IF (y_prec_state .EQ. extra_y) THEN
484 DO i = 1, n
485 y_tail( i ) = 0.0d+0
486 END DO
487 END IF
488
489 dxrat = 0.0d+0
490 dxratmax = 0.0d+0
491 dzrat = 0.0d+0
492 dzratmax = 0.0d+0
493 final_dx_x = hugeval
494 final_dz_z = hugeval
495 prevnormdx = hugeval
496 prev_dz_z = hugeval
497 dz_z = hugeval
498 dx_x = hugeval
499
500 x_state = working_state
501 z_state = unstable_state
502 incr_prec = .false.
503
504 DO cnt = 1, ithresh
505*
506* Compute residual RES = B_s - op(A_s) * Y,
507* op(A) = A, A**T, or A**H depending on TRANS (and type).
508*
509 CALL zcopy( n, b( 1, j ), 1, res, 1 )
510 IF (y_prec_state .EQ. base_residual) THEN
511 CALL zhemv(uplo, n, dcmplx(-1.0d+0), a, lda, y(1,j), 1,
512 $ dcmplx(1.0d+0), res, 1)
513 ELSE IF (y_prec_state .EQ. extra_residual) THEN
514 CALL blas_zhemv_x(uplo2, n, dcmplx(-1.0d+0), a, lda,
515 $ y( 1, j ), 1, dcmplx(1.0d+0), res, 1, prec_type)
516 ELSE
517 CALL blas_zhemv2_x(uplo2, n, dcmplx(-1.0d+0), a, lda,
518 $ y(1, j), y_tail, 1, dcmplx(1.0d+0), res, 1,
519 $ prec_type)
520 END IF
521
522! XXX: RES is no longer needed.
523 CALL zcopy( n, res, 1, dy, 1 )
524 CALL zpotrs( uplo, n, 1, af, ldaf, dy, n, info)
525*
526* Calculate relative changes DX_X, DZ_Z and ratios DXRAT, DZRAT.
527*
528 normx = 0.0d+0
529 normy = 0.0d+0
530 normdx = 0.0d+0
531 dz_z = 0.0d+0
532 ymin = hugeval
533
534 DO i = 1, n
535 yk = cabs1(y(i, j))
536 dyk = cabs1(dy(i))
537
538 IF (yk .NE. 0.0d+0) THEN
539 dz_z = max( dz_z, dyk / yk )
540 ELSE IF (dyk .NE. 0.0d+0) THEN
541 dz_z = hugeval
542 END IF
543
544 ymin = min( ymin, yk )
545
546 normy = max( normy, yk )
547
548 IF ( colequ ) THEN
549 normx = max(normx, yk * c(i))
550 normdx = max(normdx, dyk * c(i))
551 ELSE
552 normx = normy
553 normdx = max(normdx, dyk)
554 END IF
555 END DO
556
557 IF (normx .NE. 0.0d+0) THEN
558 dx_x = normdx / normx
559 ELSE IF (normdx .EQ. 0.0d+0) THEN
560 dx_x = 0.0d+0
561 ELSE
562 dx_x = hugeval
563 END IF
564
565 dxrat = normdx / prevnormdx
566 dzrat = dz_z / prev_dz_z
567*
568* Check termination criteria.
569*
570 IF (ymin*rcond .LT. incr_thresh*normy
571 $ .AND. y_prec_state .LT. extra_y)
572 $ incr_prec = .true.
573
574 IF (x_state .EQ. noprog_state .AND. dxrat .LE. rthresh)
575 $ x_state = working_state
576 IF (x_state .EQ. working_state) THEN
577 IF (dx_x .LE. eps) THEN
578 x_state = conv_state
579 ELSE IF (dxrat .GT. rthresh) THEN
580 IF (y_prec_state .NE. extra_y) THEN
581 incr_prec = .true.
582 ELSE
583 x_state = noprog_state
584 END IF
585 ELSE
586 IF (dxrat .GT. dxratmax) dxratmax = dxrat
587 END IF
588 IF (x_state .GT. working_state) final_dx_x = dx_x
589 END IF
590
591 IF (z_state .EQ. unstable_state .AND. dz_z .LE. dz_ub)
592 $ z_state = working_state
593 IF (z_state .EQ. noprog_state .AND. dzrat .LE. rthresh)
594 $ z_state = working_state
595 IF (z_state .EQ. working_state) THEN
596 IF (dz_z .LE. eps) THEN
597 z_state = conv_state
598 ELSE IF (dz_z .GT. dz_ub) THEN
599 z_state = unstable_state
600 dzratmax = 0.0d+0
601 final_dz_z = hugeval
602 ELSE IF (dzrat .GT. rthresh) THEN
603 IF (y_prec_state .NE. extra_y) THEN
604 incr_prec = .true.
605 ELSE
606 z_state = noprog_state
607 END IF
608 ELSE
609 IF (dzrat .GT. dzratmax) dzratmax = dzrat
610 END IF
611 IF (z_state .GT. working_state) final_dz_z = dz_z
612 END IF
613
614 IF ( x_state.NE.working_state.AND.
615 $ (ignore_cwise.OR.z_state.NE.working_state) )
616 $ GOTO 666
617
618 IF (incr_prec) THEN
619 incr_prec = .false.
620 y_prec_state = y_prec_state + 1
621 DO i = 1, n
622 y_tail( i ) = 0.0d+0
623 END DO
624 END IF
625
626 prevnormdx = normdx
627 prev_dz_z = dz_z
628*
629* Update solution.
630*
631 IF (y_prec_state .LT. extra_y) THEN
632 CALL zaxpy( n, dcmplx(1.0d+0), dy, 1, y(1,j), 1 )
633 ELSE
634 CALL zla_wwaddw(n, y(1,j), y_tail, dy)
635 END IF
636
637 END DO
638* Target of "IF (Z_STOP .AND. X_STOP)". Sun's f77 won't EXIT.
639 666 CONTINUE
640*
641* Set final_* when cnt hits ithresh.
642*
643 IF (x_state .EQ. working_state) final_dx_x = dx_x
644 IF (z_state .EQ. working_state) final_dz_z = dz_z
645*
646* Compute error bounds.
647*
648 IF (n_norms .GE. 1) THEN
649 err_bnds_norm( j, la_linrx_err_i ) =
650 $ final_dx_x / (1 - dxratmax)
651 END IF
652 IF (n_norms .GE. 2) THEN
653 err_bnds_comp( j, la_linrx_err_i ) =
654 $ final_dz_z / (1 - dzratmax)
655 END IF
656*
657* Compute componentwise relative backward error from formula
658* max(i) ( abs(R(i)) / ( abs(op(A_s))*abs(Y) + abs(B_s) )(i) )
659* where abs(Z) is the componentwise absolute value of the matrix
660* or vector Z.
661*
662* Compute residual RES = B_s - op(A_s) * Y,
663* op(A) = A, A**T, or A**H depending on TRANS (and type).
664*
665 CALL zcopy( n, b( 1, j ), 1, res, 1 )
666 CALL zhemv(uplo, n, dcmplx(-1.0d+0), a, lda, y(1,j), 1,
667 $ dcmplx(1.0d+0), res, 1)
668
669 DO i = 1, n
670 ayb( i ) = cabs1( b( i, j ) )
671 END DO
672*
673* Compute abs(op(A_s))*abs(Y) + abs(B_s).
674*
675 CALL zla_heamv (uplo2, n, 1.0d+0,
676 $ a, lda, y(1, j), 1, 1.0d+0, ayb, 1)
677
678 CALL zla_lin_berr (n, n, 1, res, ayb, berr_out(j))
679*
680* End of loop for each RHS.
681*
682 END DO
683*
684 RETURN
685*
686* End of ZLA_PORFSX_EXTENDED
687*
688 END
subroutine zaxpy(n, za, zx, incx, zy, incy)
ZAXPY
Definition zaxpy.f:88
subroutine zcopy(n, zx, incx, zy, incy)
ZCOPY
Definition zcopy.f:81
subroutine zhemv(uplo, n, alpha, a, lda, x, incx, beta, y, incy)
ZHEMV
Definition zhemv.f:154
subroutine zla_heamv(uplo, n, alpha, a, lda, x, incx, beta, y, incy)
ZLA_HEAMV computes a matrix-vector product using a Hermitian indefinite matrix to calculate error bou...
Definition zla_heamv.f:178
subroutine zla_lin_berr(n, nz, nrhs, res, ayb, berr)
ZLA_LIN_BERR computes a component-wise relative backward error.
subroutine zla_porfsx_extended(prec_type, uplo, n, nrhs, a, lda, af, ldaf, colequ, c, b, ldb, y, ldy, berr_out, n_norms, err_bnds_norm, err_bnds_comp, res, ayb, dy, y_tail, rcond, ithresh, rthresh, dz_ub, ignore_cwise, info)
ZLA_PORFSX_EXTENDED improves the computed solution to a system of linear equations for symmetric or H...
subroutine zla_wwaddw(n, x, y, w)
ZLA_WWADDW adds a vector into a doubled-single vector.
Definition zla_wwaddw.f:81
double precision function dlamch(cmach)
DLAMCH
Definition dlamch.f:69
subroutine zpotrs(uplo, n, nrhs, a, lda, b, ldb, info)
ZPOTRS
Definition zpotrs.f:110