LAPACK  3.10.0
LAPACK: Linear Algebra PACKage
cpprfs.f
Go to the documentation of this file.
1 *> \brief \b CPPRFS
2 *
3 * =========== DOCUMENTATION ===========
4 *
5 * Online html documentation available at
6 * http://www.netlib.org/lapack/explore-html/
7 *
8 *> \htmlonly
9 *> Download CPPRFS + dependencies
10 *> <a href="http://www.netlib.org/cgi-bin/netlibfiles.tgz?format=tgz&filename=/lapack/lapack_routine/cpprfs.f">
11 *> [TGZ]</a>
12 *> <a href="http://www.netlib.org/cgi-bin/netlibfiles.zip?format=zip&filename=/lapack/lapack_routine/cpprfs.f">
13 *> [ZIP]</a>
14 *> <a href="http://www.netlib.org/cgi-bin/netlibfiles.txt?format=txt&filename=/lapack/lapack_routine/cpprfs.f">
15 *> [TXT]</a>
16 *> \endhtmlonly
17 *
18 * Definition:
19 * ===========
20 *
21 * SUBROUTINE CPPRFS( UPLO, N, NRHS, AP, AFP, B, LDB, X, LDX, FERR,
22 * BERR, WORK, RWORK, INFO )
23 *
24 * .. Scalar Arguments ..
25 * CHARACTER UPLO
26 * INTEGER INFO, LDB, LDX, N, NRHS
27 * ..
28 * .. Array Arguments ..
29 * REAL BERR( * ), FERR( * ), RWORK( * )
30 * COMPLEX AFP( * ), AP( * ), B( LDB, * ), WORK( * ),
31 * $ X( LDX, * )
32 * ..
33 *
34 *
35 *> \par Purpose:
36 * =============
37 *>
38 *> \verbatim
39 *>
40 *> CPPRFS improves the computed solution to a system of linear
41 *> equations when the coefficient matrix is Hermitian positive definite
42 *> and packed, and provides error bounds and backward error estimates
43 *> for the solution.
44 *> \endverbatim
45 *
46 * Arguments:
47 * ==========
48 *
49 *> \param[in] UPLO
50 *> \verbatim
51 *> UPLO is CHARACTER*1
52 *> = 'U': Upper triangle of A is stored;
53 *> = 'L': Lower triangle of A is stored.
54 *> \endverbatim
55 *>
56 *> \param[in] N
57 *> \verbatim
58 *> N is INTEGER
59 *> The order of the matrix A. N >= 0.
60 *> \endverbatim
61 *>
62 *> \param[in] NRHS
63 *> \verbatim
64 *> NRHS is INTEGER
65 *> The number of right hand sides, i.e., the number of columns
66 *> of the matrices B and X. NRHS >= 0.
67 *> \endverbatim
68 *>
69 *> \param[in] AP
70 *> \verbatim
71 *> AP is COMPLEX array, dimension (N*(N+1)/2)
72 *> The upper or lower triangle of the Hermitian matrix A, packed
73 *> columnwise in a linear array. The j-th column of A is stored
74 *> in the array AP as follows:
75 *> if UPLO = 'U', AP(i + (j-1)*j/2) = A(i,j) for 1<=i<=j;
76 *> if UPLO = 'L', AP(i + (j-1)*(2n-j)/2) = A(i,j) for j<=i<=n.
77 *> \endverbatim
78 *>
79 *> \param[in] AFP
80 *> \verbatim
81 *> AFP is COMPLEX array, dimension (N*(N+1)/2)
82 *> The triangular factor U or L from the Cholesky factorization
83 *> A = U**H*U or A = L*L**H, as computed by SPPTRF/CPPTRF,
84 *> packed columnwise in a linear array in the same format as A
85 *> (see AP).
86 *> \endverbatim
87 *>
88 *> \param[in] B
89 *> \verbatim
90 *> B is COMPLEX array, dimension (LDB,NRHS)
91 *> The right hand side matrix B.
92 *> \endverbatim
93 *>
94 *> \param[in] LDB
95 *> \verbatim
96 *> LDB is INTEGER
97 *> The leading dimension of the array B. LDB >= max(1,N).
98 *> \endverbatim
99 *>
100 *> \param[in,out] X
101 *> \verbatim
102 *> X is COMPLEX array, dimension (LDX,NRHS)
103 *> On entry, the solution matrix X, as computed by CPPTRS.
104 *> On exit, the improved solution matrix X.
105 *> \endverbatim
106 *>
107 *> \param[in] LDX
108 *> \verbatim
109 *> LDX is INTEGER
110 *> The leading dimension of the array X. LDX >= max(1,N).
111 *> \endverbatim
112 *>
113 *> \param[out] FERR
114 *> \verbatim
115 *> FERR is REAL array, dimension (NRHS)
116 *> The estimated forward error bound for each solution vector
117 *> X(j) (the j-th column of the solution matrix X).
118 *> If XTRUE is the true solution corresponding to X(j), FERR(j)
119 *> is an estimated upper bound for the magnitude of the largest
120 *> element in (X(j) - XTRUE) divided by the magnitude of the
121 *> largest element in X(j). The estimate is as reliable as
122 *> the estimate for RCOND, and is almost always a slight
123 *> overestimate of the true error.
124 *> \endverbatim
125 *>
126 *> \param[out] BERR
127 *> \verbatim
128 *> BERR is REAL array, dimension (NRHS)
129 *> The componentwise relative backward error of each solution
130 *> vector X(j) (i.e., the smallest relative change in
131 *> any element of A or B that makes X(j) an exact solution).
132 *> \endverbatim
133 *>
134 *> \param[out] WORK
135 *> \verbatim
136 *> WORK is COMPLEX array, dimension (2*N)
137 *> \endverbatim
138 *>
139 *> \param[out] RWORK
140 *> \verbatim
141 *> RWORK is REAL array, dimension (N)
142 *> \endverbatim
143 *>
144 *> \param[out] INFO
145 *> \verbatim
146 *> INFO is INTEGER
147 *> = 0: successful exit
148 *> < 0: if INFO = -i, the i-th argument had an illegal value
149 *> \endverbatim
150 *
151 *> \par Internal Parameters:
152 * =========================
153 *>
154 *> \verbatim
155 *> ITMAX is the maximum number of steps of iterative refinement.
156 *> \endverbatim
157 *
158 * Authors:
159 * ========
160 *
161 *> \author Univ. of Tennessee
162 *> \author Univ. of California Berkeley
163 *> \author Univ. of Colorado Denver
164 *> \author NAG Ltd.
165 *
166 *> \ingroup complexOTHERcomputational
167 *
168 * =====================================================================
169  SUBROUTINE cpprfs( UPLO, N, NRHS, AP, AFP, B, LDB, X, LDX, FERR,
170  $ BERR, WORK, RWORK, INFO )
171 *
172 * -- LAPACK computational routine --
173 * -- LAPACK is a software package provided by Univ. of Tennessee, --
174 * -- Univ. of California Berkeley, Univ. of Colorado Denver and NAG Ltd..--
175 *
176 * .. Scalar Arguments ..
177  CHARACTER UPLO
178  INTEGER INFO, LDB, LDX, N, NRHS
179 * ..
180 * .. Array Arguments ..
181  REAL BERR( * ), FERR( * ), RWORK( * )
182  COMPLEX AFP( * ), AP( * ), B( LDB, * ), WORK( * ),
183  $ x( ldx, * )
184 * ..
185 *
186 * ====================================================================
187 *
188 * .. Parameters ..
189  INTEGER ITMAX
190  parameter( itmax = 5 )
191  REAL ZERO
192  parameter( zero = 0.0e+0 )
193  COMPLEX CONE
194  parameter( cone = ( 1.0e+0, 0.0e+0 ) )
195  REAL TWO
196  parameter( two = 2.0e+0 )
197  REAL THREE
198  parameter( three = 3.0e+0 )
199 * ..
200 * .. Local Scalars ..
201  LOGICAL UPPER
202  INTEGER COUNT, I, IK, J, K, KASE, KK, NZ
203  REAL EPS, LSTRES, S, SAFE1, SAFE2, SAFMIN, XK
204  COMPLEX ZDUM
205 * ..
206 * .. Local Arrays ..
207  INTEGER ISAVE( 3 )
208 * ..
209 * .. External Subroutines ..
210  EXTERNAL caxpy, ccopy, chpmv, clacn2, cpptrs, xerbla
211 * ..
212 * .. Intrinsic Functions ..
213  INTRINSIC abs, aimag, max, real
214 * ..
215 * .. External Functions ..
216  LOGICAL LSAME
217  REAL SLAMCH
218  EXTERNAL lsame, slamch
219 * ..
220 * .. Statement Functions ..
221  REAL CABS1
222 * ..
223 * .. Statement Function definitions ..
224  cabs1( zdum ) = abs( real( zdum ) ) + abs( aimag( zdum ) )
225 * ..
226 * .. Executable Statements ..
227 *
228 * Test the input parameters.
229 *
230  info = 0
231  upper = lsame( uplo, 'U' )
232  IF( .NOT.upper .AND. .NOT.lsame( uplo, 'L' ) ) THEN
233  info = -1
234  ELSE IF( n.LT.0 ) THEN
235  info = -2
236  ELSE IF( nrhs.LT.0 ) THEN
237  info = -3
238  ELSE IF( ldb.LT.max( 1, n ) ) THEN
239  info = -7
240  ELSE IF( ldx.LT.max( 1, n ) ) THEN
241  info = -9
242  END IF
243  IF( info.NE.0 ) THEN
244  CALL xerbla( 'CPPRFS', -info )
245  RETURN
246  END IF
247 *
248 * Quick return if possible
249 *
250  IF( n.EQ.0 .OR. nrhs.EQ.0 ) THEN
251  DO 10 j = 1, nrhs
252  ferr( j ) = zero
253  berr( j ) = zero
254  10 CONTINUE
255  RETURN
256  END IF
257 *
258 * NZ = maximum number of nonzero elements in each row of A, plus 1
259 *
260  nz = n + 1
261  eps = slamch( 'Epsilon' )
262  safmin = slamch( 'Safe minimum' )
263  safe1 = nz*safmin
264  safe2 = safe1 / eps
265 *
266 * Do for each right hand side
267 *
268  DO 140 j = 1, nrhs
269 *
270  count = 1
271  lstres = three
272  20 CONTINUE
273 *
274 * Loop until stopping criterion is satisfied.
275 *
276 * Compute residual R = B - A * X
277 *
278  CALL ccopy( n, b( 1, j ), 1, work, 1 )
279  CALL chpmv( uplo, n, -cone, ap, x( 1, j ), 1, cone, work, 1 )
280 *
281 * Compute componentwise relative backward error from formula
282 *
283 * max(i) ( abs(R(i)) / ( abs(A)*abs(X) + abs(B) )(i) )
284 *
285 * where abs(Z) is the componentwise absolute value of the matrix
286 * or vector Z. If the i-th component of the denominator is less
287 * than SAFE2, then SAFE1 is added to the i-th components of the
288 * numerator and denominator before dividing.
289 *
290  DO 30 i = 1, n
291  rwork( i ) = cabs1( b( i, j ) )
292  30 CONTINUE
293 *
294 * Compute abs(A)*abs(X) + abs(B).
295 *
296  kk = 1
297  IF( upper ) THEN
298  DO 50 k = 1, n
299  s = zero
300  xk = cabs1( x( k, j ) )
301  ik = kk
302  DO 40 i = 1, k - 1
303  rwork( i ) = rwork( i ) + cabs1( ap( ik ) )*xk
304  s = s + cabs1( ap( ik ) )*cabs1( x( i, j ) )
305  ik = ik + 1
306  40 CONTINUE
307  rwork( k ) = rwork( k ) + abs( real( ap( kk+k-1 ) ) )*
308  $ xk + s
309  kk = kk + k
310  50 CONTINUE
311  ELSE
312  DO 70 k = 1, n
313  s = zero
314  xk = cabs1( x( k, j ) )
315  rwork( k ) = rwork( k ) + abs( real( ap( kk ) ) )*xk
316  ik = kk + 1
317  DO 60 i = k + 1, n
318  rwork( i ) = rwork( i ) + cabs1( ap( ik ) )*xk
319  s = s + cabs1( ap( ik ) )*cabs1( x( i, j ) )
320  ik = ik + 1
321  60 CONTINUE
322  rwork( k ) = rwork( k ) + s
323  kk = kk + ( n-k+1 )
324  70 CONTINUE
325  END IF
326  s = zero
327  DO 80 i = 1, n
328  IF( rwork( i ).GT.safe2 ) THEN
329  s = max( s, cabs1( work( i ) ) / rwork( i ) )
330  ELSE
331  s = max( s, ( cabs1( work( i ) )+safe1 ) /
332  $ ( rwork( i )+safe1 ) )
333  END IF
334  80 CONTINUE
335  berr( j ) = s
336 *
337 * Test stopping criterion. Continue iterating if
338 * 1) The residual BERR(J) is larger than machine epsilon, and
339 * 2) BERR(J) decreased by at least a factor of 2 during the
340 * last iteration, and
341 * 3) At most ITMAX iterations tried.
342 *
343  IF( berr( j ).GT.eps .AND. two*berr( j ).LE.lstres .AND.
344  $ count.LE.itmax ) THEN
345 *
346 * Update solution and try again.
347 *
348  CALL cpptrs( uplo, n, 1, afp, work, n, info )
349  CALL caxpy( n, cone, work, 1, x( 1, j ), 1 )
350  lstres = berr( j )
351  count = count + 1
352  GO TO 20
353  END IF
354 *
355 * Bound error from formula
356 *
357 * norm(X - XTRUE) / norm(X) .le. FERR =
358 * norm( abs(inv(A))*
359 * ( abs(R) + NZ*EPS*( abs(A)*abs(X)+abs(B) ))) / norm(X)
360 *
361 * where
362 * norm(Z) is the magnitude of the largest component of Z
363 * inv(A) is the inverse of A
364 * abs(Z) is the componentwise absolute value of the matrix or
365 * vector Z
366 * NZ is the maximum number of nonzeros in any row of A, plus 1
367 * EPS is machine epsilon
368 *
369 * The i-th component of abs(R)+NZ*EPS*(abs(A)*abs(X)+abs(B))
370 * is incremented by SAFE1 if the i-th component of
371 * abs(A)*abs(X) + abs(B) is less than SAFE2.
372 *
373 * Use CLACN2 to estimate the infinity-norm of the matrix
374 * inv(A) * diag(W),
375 * where W = abs(R) + NZ*EPS*( abs(A)*abs(X)+abs(B) )))
376 *
377  DO 90 i = 1, n
378  IF( rwork( i ).GT.safe2 ) THEN
379  rwork( i ) = cabs1( work( i ) ) + nz*eps*rwork( i )
380  ELSE
381  rwork( i ) = cabs1( work( i ) ) + nz*eps*rwork( i ) +
382  $ safe1
383  END IF
384  90 CONTINUE
385 *
386  kase = 0
387  100 CONTINUE
388  CALL clacn2( n, work( n+1 ), work, ferr( j ), kase, isave )
389  IF( kase.NE.0 ) THEN
390  IF( kase.EQ.1 ) THEN
391 *
392 * Multiply by diag(W)*inv(A**H).
393 *
394  CALL cpptrs( uplo, n, 1, afp, work, n, info )
395  DO 110 i = 1, n
396  work( i ) = rwork( i )*work( i )
397  110 CONTINUE
398  ELSE IF( kase.EQ.2 ) THEN
399 *
400 * Multiply by inv(A)*diag(W).
401 *
402  DO 120 i = 1, n
403  work( i ) = rwork( i )*work( i )
404  120 CONTINUE
405  CALL cpptrs( uplo, n, 1, afp, work, n, info )
406  END IF
407  GO TO 100
408  END IF
409 *
410 * Normalize error.
411 *
412  lstres = zero
413  DO 130 i = 1, n
414  lstres = max( lstres, cabs1( x( i, j ) ) )
415  130 CONTINUE
416  IF( lstres.NE.zero )
417  $ ferr( j ) = ferr( j ) / lstres
418 *
419  140 CONTINUE
420 *
421  RETURN
422 *
423 * End of CPPRFS
424 *
425  END
subroutine xerbla(SRNAME, INFO)
XERBLA
Definition: xerbla.f:60
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 chpmv(UPLO, N, ALPHA, AP, X, INCX, BETA, Y, INCY)
CHPMV
Definition: chpmv.f:149
subroutine clacn2(N, V, X, EST, KASE, ISAVE)
CLACN2 estimates the 1-norm of a square matrix, using reverse communication for evaluating matrix-vec...
Definition: clacn2.f:133
subroutine cpptrs(UPLO, N, NRHS, AP, B, LDB, INFO)
CPPTRS
Definition: cpptrs.f:108
subroutine cpprfs(UPLO, N, NRHS, AP, AFP, B, LDB, X, LDX, FERR, BERR, WORK, RWORK, INFO)
CPPRFS
Definition: cpprfs.f:171