LAPACK  3.10.1
LAPACK: Linear Algebra PACKage
cla_gerfsx_extended.f
Go to the documentation of this file.
1 *> \brief \b CLA_GERFSX_EXTENDED
2 *
3 * =========== DOCUMENTATION ===========
4 *
5 * Online html documentation available at
6 * http://www.netlib.org/lapack/explore-html/
7 *
8 *> \htmlonly
9 *> Download CLA_GERFSX_EXTENDED + dependencies
10 *> <a href="http://www.netlib.org/cgi-bin/netlibfiles.tgz?format=tgz&filename=/lapack/lapack_routine/cla_gerfsx_extended.f">
11 *> [TGZ]</a>
12 *> <a href="http://www.netlib.org/cgi-bin/netlibfiles.zip?format=zip&filename=/lapack/lapack_routine/cla_gerfsx_extended.f">
13 *> [ZIP]</a>
14 *> <a href="http://www.netlib.org/cgi-bin/netlibfiles.txt?format=txt&filename=/lapack/lapack_routine/cla_gerfsx_extended.f">
15 *> [TXT]</a>
16 *> \endhtmlonly
17 *
18 * Definition:
19 * ===========
20 *
21 * SUBROUTINE CLA_GERFSX_EXTENDED( PREC_TYPE, TRANS_TYPE, N, NRHS, A,
22 * LDA, AF, LDAF, IPIV, COLEQU, C, B,
23 * LDB, Y, LDY, BERR_OUT, N_NORMS,
24 * ERRS_N, ERRS_C, RES, AYB, DY,
25 * Y_TAIL, RCOND, ITHRESH, RTHRESH,
26 * DZ_UB, IGNORE_CWISE, INFO )
27 *
28 * .. Scalar Arguments ..
29 * INTEGER INFO, LDA, LDAF, LDB, LDY, N, NRHS, PREC_TYPE,
30 * $ TRANS_TYPE, N_NORMS
31 * LOGICAL COLEQU, IGNORE_CWISE
32 * INTEGER ITHRESH
33 * REAL RTHRESH, DZ_UB
34 * ..
35 * .. Array Arguments
36 * INTEGER IPIV( * )
37 * COMPLEX A( LDA, * ), AF( LDAF, * ), B( LDB, * ),
38 * $ Y( LDY, * ), RES( * ), DY( * ), Y_TAIL( * )
39 * REAL C( * ), AYB( * ), RCOND, BERR_OUT( * ),
40 * $ ERRS_N( NRHS, * ), ERRS_C( NRHS, * )
41 * ..
42 *
43 *
44 *> \par Purpose:
45 * =============
46 *>
47 *> \verbatim
48 *>
49 *>
50 *> CLA_GERFSX_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 CGERFSX to perform iterative refinement.
54 *> In addition to normwise error bound, the code provides maximum
55 *> componentwise error bound if possible. See comments for ERRS_N
56 *> and ERRS_C for details of the error bounds. Note that this
57 *> subroutine is only responsible for setting the second fields of
58 *> ERRS_N and ERRS_C.
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] TRANS_TYPE
76 *> \verbatim
77 *> TRANS_TYPE is INTEGER
78 *> Specifies the transposition operation on A.
79 *> The value is defined by ILATRANS(T) where T is a CHARACTER and T
80 *> = 'N': No transpose
81 *> = 'T': Transpose
82 *> = 'C': Conjugate transpose
83 *> \endverbatim
84 *>
85 *> \param[in] N
86 *> \verbatim
87 *> N is INTEGER
88 *> The number of linear equations, i.e., the order of the
89 *> matrix A. N >= 0.
90 *> \endverbatim
91 *>
92 *> \param[in] NRHS
93 *> \verbatim
94 *> NRHS is INTEGER
95 *> The number of right-hand-sides, i.e., the number of columns of the
96 *> matrix B.
97 *> \endverbatim
98 *>
99 *> \param[in] A
100 *> \verbatim
101 *> A is COMPLEX array, dimension (LDA,N)
102 *> On entry, the N-by-N matrix A.
103 *> \endverbatim
104 *>
105 *> \param[in] LDA
106 *> \verbatim
107 *> LDA is INTEGER
108 *> The leading dimension of the array A. LDA >= max(1,N).
109 *> \endverbatim
110 *>
111 *> \param[in] AF
112 *> \verbatim
113 *> AF is COMPLEX array, dimension (LDAF,N)
114 *> The factors L and U from the factorization
115 *> A = P*L*U as computed by CGETRF.
116 *> \endverbatim
117 *>
118 *> \param[in] LDAF
119 *> \verbatim
120 *> LDAF is INTEGER
121 *> The leading dimension of the array AF. LDAF >= max(1,N).
122 *> \endverbatim
123 *>
124 *> \param[in] IPIV
125 *> \verbatim
126 *> IPIV is INTEGER array, dimension (N)
127 *> The pivot indices from the factorization A = P*L*U
128 *> as computed by CGETRF; row i of the matrix was interchanged
129 *> with row IPIV(i).
130 *> \endverbatim
131 *>
132 *> \param[in] COLEQU
133 *> \verbatim
134 *> COLEQU is LOGICAL
135 *> If .TRUE. then column equilibration was done to A before calling
136 *> this routine. This is needed to compute the solution and error
137 *> bounds correctly.
138 *> \endverbatim
139 *>
140 *> \param[in] C
141 *> \verbatim
142 *> C is REAL array, dimension (N)
143 *> The column scale factors for A. If COLEQU = .FALSE., C
144 *> is not accessed. If C is input, each element of C should be a power
145 *> of the radix to ensure a reliable solution and error estimates.
146 *> Scaling by powers of the radix does not cause rounding errors unless
147 *> the result underflows or overflows. Rounding errors during scaling
148 *> lead to refining with a matrix that is not equivalent to the
149 *> input matrix, producing error estimates that may not be
150 *> reliable.
151 *> \endverbatim
152 *>
153 *> \param[in] B
154 *> \verbatim
155 *> B is COMPLEX array, dimension (LDB,NRHS)
156 *> The right-hand-side matrix B.
157 *> \endverbatim
158 *>
159 *> \param[in] LDB
160 *> \verbatim
161 *> LDB is INTEGER
162 *> The leading dimension of the array B. LDB >= max(1,N).
163 *> \endverbatim
164 *>
165 *> \param[in,out] Y
166 *> \verbatim
167 *> Y is COMPLEX array, dimension (LDY,NRHS)
168 *> On entry, the solution matrix X, as computed by CGETRS.
169 *> On exit, the improved solution matrix Y.
170 *> \endverbatim
171 *>
172 *> \param[in] LDY
173 *> \verbatim
174 *> LDY is INTEGER
175 *> The leading dimension of the array Y. LDY >= max(1,N).
176 *> \endverbatim
177 *>
178 *> \param[out] BERR_OUT
179 *> \verbatim
180 *> BERR_OUT is REAL array, dimension (NRHS)
181 *> On exit, BERR_OUT(j) contains the componentwise relative backward
182 *> error for right-hand-side j from the formula
183 *> max(i) ( abs(RES(i)) / ( abs(op(A_s))*abs(Y) + abs(B_s) )(i) )
184 *> where abs(Z) is the componentwise absolute value of the matrix
185 *> or vector Z. This is computed by CLA_LIN_BERR.
186 *> \endverbatim
187 *>
188 *> \param[in] N_NORMS
189 *> \verbatim
190 *> N_NORMS is INTEGER
191 *> Determines which error bounds to return (see ERRS_N
192 *> and ERRS_C).
193 *> If N_NORMS >= 1 return normwise error bounds.
194 *> If N_NORMS >= 2 return componentwise error bounds.
195 *> \endverbatim
196 *>
197 *> \param[in,out] ERRS_N
198 *> \verbatim
199 *> ERRS_N is REAL array, dimension (NRHS, N_ERR_BNDS)
200 *> For each right-hand side, this array contains information about
201 *> various error bounds and condition numbers corresponding to the
202 *> normwise relative error, which is defined as follows:
203 *>
204 *> Normwise relative error in the ith solution vector:
205 *> max_j (abs(XTRUE(j,i) - X(j,i)))
206 *> ------------------------------
207 *> max_j abs(X(j,i))
208 *>
209 *> The array is indexed by the type of error information as described
210 *> below. There currently are up to three pieces of information
211 *> returned.
212 *>
213 *> The first index in ERRS_N(i,:) corresponds to the ith
214 *> right-hand side.
215 *>
216 *> The second index in ERRS_N(:,err) contains the following
217 *> three fields:
218 *> err = 1 "Trust/don't trust" boolean. Trust the answer if the
219 *> reciprocal condition number is less than the threshold
220 *> sqrt(n) * slamch('Epsilon').
221 *>
222 *> err = 2 "Guaranteed" error bound: The estimated forward error,
223 *> almost certainly within a factor of 10 of the true error
224 *> so long as the next entry is greater than the threshold
225 *> sqrt(n) * slamch('Epsilon'). This error bound should only
226 *> be trusted if the previous boolean is true.
227 *>
228 *> err = 3 Reciprocal condition number: Estimated normwise
229 *> reciprocal condition number. Compared with the threshold
230 *> sqrt(n) * slamch('Epsilon') to determine if the error
231 *> estimate is "guaranteed". These reciprocal condition
232 *> numbers are 1 / (norm(Z^{-1},inf) * norm(Z,inf)) for some
233 *> appropriately scaled matrix Z.
234 *> Let Z = S*A, where S scales each row by a power of the
235 *> radix so all absolute row sums of Z are approximately 1.
236 *>
237 *> This subroutine is only responsible for setting the second field
238 *> above.
239 *> See Lapack Working Note 165 for further details and extra
240 *> cautions.
241 *> \endverbatim
242 *>
243 *> \param[in,out] ERRS_C
244 *> \verbatim
245 *> ERRS_C is REAL array, dimension (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 *> ERRS_C is not accessed. If N_ERR_BNDS < 3, then at most
261 *> the first (:,N_ERR_BNDS) entries are returned.
262 *>
263 *> The first index in ERRS_C(i,:) corresponds to the ith
264 *> right-hand side.
265 *>
266 *> The second index in ERRS_C(:,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 *> ERRS_N and ERRS_C 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 define 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 CGETRS 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 *> \ingroup complexGEcomputational
389 *
390 * =====================================================================
391  SUBROUTINE cla_gerfsx_extended( PREC_TYPE, TRANS_TYPE, N, NRHS, A,
392  $ LDA, AF, LDAF, IPIV, COLEQU, C, B,
393  $ LDB, Y, LDY, BERR_OUT, N_NORMS,
394  $ ERRS_N, ERRS_C, RES, AYB, DY,
395  $ Y_TAIL, RCOND, ITHRESH, RTHRESH,
396  $ DZ_UB, IGNORE_CWISE, INFO )
397 *
398 * -- LAPACK computational routine --
399 * -- LAPACK is a software package provided by Univ. of Tennessee, --
400 * -- Univ. of California Berkeley, Univ. of Colorado Denver and NAG Ltd..--
401 *
402 * .. Scalar Arguments ..
403  INTEGER INFO, LDA, LDAF, LDB, LDY, N, NRHS, PREC_TYPE,
404  $ TRANS_TYPE, N_NORMS
405  LOGICAL COLEQU, IGNORE_CWISE
406  INTEGER ITHRESH
407  REAL RTHRESH, DZ_UB
408 * ..
409 * .. Array Arguments
410  INTEGER IPIV( * )
411  COMPLEX A( LDA, * ), AF( LDAF, * ), B( LDB, * ),
412  $ y( ldy, * ), res( * ), dy( * ), y_tail( * )
413  REAL C( * ), AYB( * ), RCOND, BERR_OUT( * ),
414  $ ERRS_N( NRHS, * ), ERRS_C( NRHS, * )
415 * ..
416 *
417 * =====================================================================
418 *
419 * .. Local Scalars ..
420  CHARACTER TRANS
421  INTEGER CNT, I, J, X_STATE, Z_STATE, Y_PREC_STATE
422  REAL YK, DYK, YMIN, NORMY, NORMX, NORMDX, DXRAT,
423  $ DZRAT, PREVNORMDX, PREV_DZ_Z, DXRATMAX,
424  $ DZRATMAX, DX_X, DZ_Z, FINAL_DX_X, FINAL_DZ_Z,
425  $ eps, hugeval, incr_thresh
426  LOGICAL INCR_PREC
427  COMPLEX ZDUM
428 * ..
429 * .. Parameters ..
430  INTEGER UNSTABLE_STATE, WORKING_STATE, CONV_STATE,
431  $ noprog_state, base_residual, extra_residual,
432  $ extra_y
433  parameter( unstable_state = 0, working_state = 1,
434  $ conv_state = 2,
435  $ noprog_state = 3 )
436  parameter( base_residual = 0, extra_residual = 1,
437  $ extra_y = 2 )
438  INTEGER FINAL_NRM_ERR_I, FINAL_CMP_ERR_I, BERR_I
439  INTEGER RCOND_I, NRM_RCOND_I, NRM_ERR_I, CMP_RCOND_I
440  INTEGER CMP_ERR_I, PIV_GROWTH_I
441  parameter( final_nrm_err_i = 1, final_cmp_err_i = 2,
442  $ berr_i = 3 )
443  parameter( rcond_i = 4, nrm_rcond_i = 5, nrm_err_i = 6 )
444  parameter( cmp_rcond_i = 7, cmp_err_i = 8,
445  $ piv_growth_i = 9 )
446  INTEGER LA_LINRX_ITREF_I, LA_LINRX_ITHRESH_I,
447  $ LA_LINRX_CWISE_I
448  parameter( la_linrx_itref_i = 1,
449  $ la_linrx_ithresh_i = 2 )
450  parameter( la_linrx_cwise_i = 3 )
451  INTEGER LA_LINRX_TRUST_I, LA_LINRX_ERR_I,
452  $ LA_LINRX_RCOND_I
453  parameter( la_linrx_trust_i = 1, la_linrx_err_i = 2 )
454  parameter( la_linrx_rcond_i = 3 )
455 * ..
456 * .. External Subroutines ..
457  EXTERNAL caxpy, ccopy, cgetrs, cgemv, blas_cgemv_x,
458  $ blas_cgemv2_x, cla_geamv, cla_wwaddw, slamch,
460  REAL SLAMCH
461  CHARACTER CHLA_TRANSTYPE
462 * ..
463 * .. Intrinsic Functions ..
464  INTRINSIC abs, max, min
465 * ..
466 * .. Statement Functions ..
467  REAL CABS1
468 * ..
469 * .. Statement Function Definitions ..
470  cabs1( zdum ) = abs( real( zdum ) ) + abs( aimag( zdum ) )
471 * ..
472 * .. Executable Statements ..
473 *
474  IF ( info.NE.0 ) RETURN
475  trans = chla_transtype(trans_type)
476  eps = slamch( 'Epsilon' )
477  hugeval = slamch( 'Overflow' )
478 * Force HUGEVAL to Inf
479  hugeval = hugeval * hugeval
480 * Using HUGEVAL may lead to spurious underflows.
481  incr_thresh = real( n ) * eps
482 *
483  DO j = 1, nrhs
484  y_prec_state = extra_residual
485  IF ( y_prec_state .EQ. extra_y ) THEN
486  DO i = 1, n
487  y_tail( i ) = 0.0
488  END DO
489  END IF
490 
491  dxrat = 0.0
492  dxratmax = 0.0
493  dzrat = 0.0
494  dzratmax = 0.0
495  final_dx_x = hugeval
496  final_dz_z = hugeval
497  prevnormdx = hugeval
498  prev_dz_z = hugeval
499  dz_z = hugeval
500  dx_x = hugeval
501 
502  x_state = working_state
503  z_state = unstable_state
504  incr_prec = .false.
505 
506  DO cnt = 1, ithresh
507 *
508 * Compute residual RES = B_s - op(A_s) * Y,
509 * op(A) = A, A**T, or A**H depending on TRANS (and type).
510 *
511  CALL ccopy( n, b( 1, j ), 1, res, 1 )
512  IF ( y_prec_state .EQ. base_residual ) THEN
513  CALL cgemv( trans, n, n, (-1.0e+0,0.0e+0), a, lda,
514  $ y( 1, j ), 1, (1.0e+0,0.0e+0), res, 1)
515  ELSE IF (y_prec_state .EQ. extra_residual) THEN
516  CALL blas_cgemv_x( trans_type, n, n, (-1.0e+0,0.0e+0), a,
517  $ lda, y( 1, j ), 1, (1.0e+0,0.0e+0),
518  $ res, 1, prec_type )
519  ELSE
520  CALL blas_cgemv2_x( trans_type, n, n, (-1.0e+0,0.0e+0),
521  $ a, lda, y(1, j), y_tail, 1, (1.0e+0,0.0e+0), res, 1,
522  $ prec_type)
523  END IF
524 
525 ! XXX: RES is no longer needed.
526  CALL ccopy( n, res, 1, dy, 1 )
527  CALL cgetrs( trans, n, 1, af, ldaf, ipiv, dy, n, info )
528 *
529 * Calculate relative changes DX_X, DZ_Z and ratios DXRAT, DZRAT.
530 *
531  normx = 0.0e+0
532  normy = 0.0e+0
533  normdx = 0.0e+0
534  dz_z = 0.0e+0
535  ymin = hugeval
536 *
537  DO i = 1, n
538  yk = cabs1( y( i, j ) )
539  dyk = cabs1( dy( i ) )
540 
541  IF ( yk .NE. 0.0e+0 ) THEN
542  dz_z = max( dz_z, dyk / yk )
543  ELSE IF ( dyk .NE. 0.0 ) THEN
544  dz_z = hugeval
545  END IF
546 
547  ymin = min( ymin, yk )
548 
549  normy = max( normy, yk )
550 
551  IF ( colequ ) THEN
552  normx = max( normx, yk * c( i ) )
553  normdx = max( normdx, dyk * c( i ) )
554  ELSE
555  normx = normy
556  normdx = max(normdx, dyk)
557  END IF
558  END DO
559 
560  IF ( normx .NE. 0.0 ) THEN
561  dx_x = normdx / normx
562  ELSE IF ( normdx .EQ. 0.0 ) THEN
563  dx_x = 0.0
564  ELSE
565  dx_x = hugeval
566  END IF
567 
568  dxrat = normdx / prevnormdx
569  dzrat = dz_z / prev_dz_z
570 *
571 * Check termination criteria
572 *
573  IF (.NOT.ignore_cwise
574  $ .AND. ymin*rcond .LT. incr_thresh*normy
575  $ .AND. y_prec_state .LT. extra_y )
576  $ incr_prec = .true.
577 
578  IF ( x_state .EQ. noprog_state .AND. dxrat .LE. rthresh )
579  $ x_state = working_state
580  IF ( x_state .EQ. working_state ) THEN
581  IF (dx_x .LE. eps) THEN
582  x_state = conv_state
583  ELSE IF ( dxrat .GT. rthresh ) THEN
584  IF ( y_prec_state .NE. extra_y ) THEN
585  incr_prec = .true.
586  ELSE
587  x_state = noprog_state
588  END IF
589  ELSE
590  IF ( dxrat .GT. dxratmax ) dxratmax = dxrat
591  END IF
592  IF ( x_state .GT. working_state ) final_dx_x = dx_x
593  END IF
594 
595  IF ( z_state .EQ. unstable_state .AND. dz_z .LE. dz_ub )
596  $ z_state = working_state
597  IF ( z_state .EQ. noprog_state .AND. dzrat .LE. rthresh )
598  $ z_state = working_state
599  IF ( z_state .EQ. working_state ) THEN
600  IF ( dz_z .LE. eps ) THEN
601  z_state = conv_state
602  ELSE IF ( dz_z .GT. dz_ub ) THEN
603  z_state = unstable_state
604  dzratmax = 0.0
605  final_dz_z = hugeval
606  ELSE IF ( dzrat .GT. rthresh ) THEN
607  IF ( y_prec_state .NE. extra_y ) THEN
608  incr_prec = .true.
609  ELSE
610  z_state = noprog_state
611  END IF
612  ELSE
613  IF ( dzrat .GT. dzratmax ) dzratmax = dzrat
614  END IF
615  IF ( z_state .GT. working_state ) final_dz_z = dz_z
616  END IF
617 *
618 * Exit if both normwise and componentwise stopped working,
619 * but if componentwise is unstable, let it go at least two
620 * iterations.
621 *
622  IF ( x_state.NE.working_state ) THEN
623  IF ( ignore_cwise ) GOTO 666
624  IF ( z_state.EQ.noprog_state .OR. z_state.EQ.conv_state )
625  $ GOTO 666
626  IF ( z_state.EQ.unstable_state .AND. cnt.GT.1 ) GOTO 666
627  END IF
628 
629  IF ( incr_prec ) THEN
630  incr_prec = .false.
631  y_prec_state = y_prec_state + 1
632  DO i = 1, n
633  y_tail( i ) = 0.0
634  END DO
635  END IF
636 
637  prevnormdx = normdx
638  prev_dz_z = dz_z
639 *
640 * Update soluton.
641 *
642  IF ( y_prec_state .LT. extra_y ) THEN
643  CALL caxpy( n, (1.0e+0,0.0e+0), dy, 1, y(1,j), 1 )
644  ELSE
645  CALL cla_wwaddw( n, y( 1, j ), y_tail, dy )
646  END IF
647 
648  END DO
649 * Target of "IF (Z_STOP .AND. X_STOP)". Sun's f77 won't EXIT.
650  666 CONTINUE
651 *
652 * Set final_* when cnt hits ithresh
653 *
654  IF ( x_state .EQ. working_state ) final_dx_x = dx_x
655  IF ( z_state .EQ. working_state ) final_dz_z = dz_z
656 *
657 * Compute error bounds
658 *
659  IF (n_norms .GE. 1) THEN
660  errs_n( j, la_linrx_err_i ) = final_dx_x / (1 - dxratmax)
661 
662  END IF
663  IF ( n_norms .GE. 2 ) THEN
664  errs_c( j, la_linrx_err_i ) = final_dz_z / (1 - dzratmax)
665  END IF
666 *
667 * Compute componentwise relative backward error from formula
668 * max(i) ( abs(R(i)) / ( abs(op(A_s))*abs(Y) + abs(B_s) )(i) )
669 * where abs(Z) is the componentwise absolute value of the matrix
670 * or vector Z.
671 *
672 * Compute residual RES = B_s - op(A_s) * Y,
673 * op(A) = A, A**T, or A**H depending on TRANS (and type).
674 *
675  CALL ccopy( n, b( 1, j ), 1, res, 1 )
676  CALL cgemv( trans, n, n, (-1.0e+0,0.0e+0), a, lda, y(1,j), 1,
677  $ (1.0e+0,0.0e+0), res, 1 )
678 
679  DO i = 1, n
680  ayb( i ) = cabs1( b( i, j ) )
681  END DO
682 *
683 * Compute abs(op(A_s))*abs(Y) + abs(B_s).
684 *
685  CALL cla_geamv ( trans_type, n, n, 1.0e+0,
686  $ a, lda, y(1, j), 1, 1.0e+0, ayb, 1 )
687 
688  CALL cla_lin_berr ( n, n, 1, res, ayb, berr_out( j ) )
689 *
690 * End of loop for each RHS.
691 *
692  END DO
693 *
694  RETURN
695 *
696 * End of CLA_GERFSX_EXTENDED
697 *
698  END
character *1 function chla_transtype(TRANS)
CHLA_TRANSTYPE
subroutine ccopy(N, CX, INCX, CY, INCY)
CCOPY
Definition: ccopy.f:81
subroutine caxpy(N, CA, CX, INCX, CY, INCY)
CAXPY
Definition: caxpy.f:88
subroutine cgemv(TRANS, M, N, ALPHA, A, LDA, X, INCX, BETA, Y, INCY)
CGEMV
Definition: cgemv.f:158
subroutine cgetrs(TRANS, N, NRHS, A, LDA, IPIV, B, LDB, INFO)
CGETRS
Definition: cgetrs.f:121
subroutine cla_gerfsx_extended(PREC_TYPE, TRANS_TYPE, N, NRHS, A, LDA, AF, LDAF, IPIV, COLEQU, C, B, LDB, Y, LDY, BERR_OUT, N_NORMS, ERRS_N, ERRS_C, RES, AYB, DY, Y_TAIL, RCOND, ITHRESH, RTHRESH, DZ_UB, IGNORE_CWISE, INFO)
CLA_GERFSX_EXTENDED
subroutine cla_geamv(TRANS, M, N, ALPHA, A, LDA, X, INCX, BETA, Y, INCY)
CLA_GEAMV computes a matrix-vector product using a general matrix to calculate error bounds.
Definition: cla_geamv.f:175
subroutine cla_wwaddw(N, X, Y, W)
CLA_WWADDW adds a vector into a doubled-single vector.
Definition: cla_wwaddw.f:81
subroutine cla_lin_berr(N, NZ, NRHS, RES, AYB, BERR)
CLA_LIN_BERR computes a component-wise relative backward error.
Definition: cla_lin_berr.f:101
real function slamch(CMACH)
SLAMCH
Definition: slamch.f:68