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