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