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