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