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