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