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