LAPACK  3.10.1 LAPACK: Linear Algebra PACKage

## ◆ zptsvx()

 subroutine zptsvx ( character FACT, integer N, integer NRHS, double precision, dimension( * ) D, complex*16, dimension( * ) E, double precision, dimension( * ) DF, complex*16, dimension( * ) EF, complex*16, dimension( ldb, * ) B, integer LDB, complex*16, dimension( ldx, * ) X, integer LDX, double precision RCOND, double precision, dimension( * ) FERR, double precision, dimension( * ) BERR, complex*16, dimension( * ) WORK, double precision, dimension( * ) RWORK, integer INFO )

ZPTSVX computes the solution to system of linear equations A * X = B for PT matrices

Purpose:
ZPTSVX uses the factorization A = L*D*L**H to compute the solution
to a complex system of linear equations A*X = B, where A is an
N-by-N Hermitian positive definite tridiagonal matrix and X and B
are N-by-NRHS matrices.

Error bounds on the solution and a condition estimate are also
provided.
Description:
The following steps are performed:

1. If FACT = 'N', the matrix A is factored as A = L*D*L**H, where L
is a unit lower bidiagonal matrix and D is diagonal.  The
factorization can also be regarded as having the form
A = U**H*D*U.

2. If the leading i-by-i principal minor is not positive definite,
then the routine returns with INFO = i. Otherwise, the factored
form of A is used to estimate the condition number of the matrix
A.  If the reciprocal of the condition number is less than machine
precision, INFO = N+1 is returned as a warning, but the routine
still goes on to solve for X and compute error bounds as
described below.

3. The system of equations is solved for X using the factored form
of A.

4. Iterative refinement is applied to improve the computed solution
matrix and calculate error bounds and backward error estimates
for it.
Parameters
 [in] FACT FACT is CHARACTER*1 Specifies whether or not the factored form of the matrix A is supplied on entry. = 'F': On entry, DF and EF contain the factored form of A. D, E, DF, and EF will not be modified. = 'N': The matrix A will be copied to DF and EF and factored. [in] N N is INTEGER The order of the matrix A. N >= 0. [in] NRHS NRHS is INTEGER The number of right hand sides, i.e., the number of columns of the matrices B and X. NRHS >= 0. [in] D D is DOUBLE PRECISION array, dimension (N) The n diagonal elements of the tridiagonal matrix A. [in] E E is COMPLEX*16 array, dimension (N-1) The (n-1) subdiagonal elements of the tridiagonal matrix A. [in,out] DF DF is DOUBLE PRECISION array, dimension (N) If FACT = 'F', then DF is an input argument and on entry contains the n diagonal elements of the diagonal matrix D from the L*D*L**H factorization of A. If FACT = 'N', then DF is an output argument and on exit contains the n diagonal elements of the diagonal matrix D from the L*D*L**H factorization of A. [in,out] EF EF is COMPLEX*16 array, dimension (N-1) If FACT = 'F', then EF is an input argument and on entry contains the (n-1) subdiagonal elements of the unit bidiagonal factor L from the L*D*L**H factorization of A. If FACT = 'N', then EF is an output argument and on exit contains the (n-1) subdiagonal elements of the unit bidiagonal factor L from the L*D*L**H factorization of A. [in] B B is COMPLEX*16 array, dimension (LDB,NRHS) The N-by-NRHS right hand side matrix B. [in] LDB LDB is INTEGER The leading dimension of the array B. LDB >= max(1,N). [out] X X is COMPLEX*16 array, dimension (LDX,NRHS) If INFO = 0 or INFO = N+1, the N-by-NRHS solution matrix X. [in] LDX LDX is INTEGER The leading dimension of the array X. LDX >= max(1,N). [out] RCOND RCOND is DOUBLE PRECISION The reciprocal condition number of the matrix A. If RCOND is less than the machine precision (in particular, if RCOND = 0), the matrix is singular to working precision. This condition is indicated by a return code of INFO > 0. [out] FERR FERR is DOUBLE PRECISION array, dimension (NRHS) The forward error bound for each solution vector X(j) (the j-th column of the solution matrix X). If XTRUE is the true solution corresponding to X(j), FERR(j) is an estimated upper bound for the magnitude of the largest element in (X(j) - XTRUE) divided by the magnitude of the largest element in X(j). [out] BERR BERR is DOUBLE PRECISION array, dimension (NRHS) The componentwise relative backward error of each solution vector X(j) (i.e., the smallest relative change in any element of A or B that makes X(j) an exact solution). [out] WORK WORK is COMPLEX*16 array, dimension (N) [out] RWORK RWORK is DOUBLE PRECISION array, dimension (N) [out] INFO INFO is INTEGER = 0: successful exit < 0: if INFO = -i, the i-th argument had an illegal value > 0: if INFO = i, and i is <= N: the leading minor of order i of A is not positive definite, so the factorization could not be completed, and the solution has not been computed. RCOND = 0 is returned. = N+1: U is nonsingular, but RCOND is less than machine precision, meaning that the matrix is singular to working precision. Nevertheless, the solution and error bounds are computed because there are a number of situations where the computed solution can be more accurate than the value of RCOND would suggest.

Definition at line 232 of file zptsvx.f.

234 *
235 * -- LAPACK driver routine --
236 * -- LAPACK is a software package provided by Univ. of Tennessee, --
237 * -- Univ. of California Berkeley, Univ. of Colorado Denver and NAG Ltd..--
238 *
239 * .. Scalar Arguments ..
240  CHARACTER FACT
241  INTEGER INFO, LDB, LDX, N, NRHS
242  DOUBLE PRECISION RCOND
243 * ..
244 * .. Array Arguments ..
245  DOUBLE PRECISION BERR( * ), D( * ), DF( * ), FERR( * ),
246  \$ RWORK( * )
247  COMPLEX*16 B( LDB, * ), E( * ), EF( * ), WORK( * ),
248  \$ X( LDX, * )
249 * ..
250 *
251 * =====================================================================
252 *
253 * .. Parameters ..
254  DOUBLE PRECISION ZERO
255  parameter( zero = 0.0d+0 )
256 * ..
257 * .. Local Scalars ..
258  LOGICAL NOFACT
259  DOUBLE PRECISION ANORM
260 * ..
261 * .. External Functions ..
262  LOGICAL LSAME
263  DOUBLE PRECISION DLAMCH, ZLANHT
264  EXTERNAL lsame, dlamch, zlanht
265 * ..
266 * .. External Subroutines ..
267  EXTERNAL dcopy, xerbla, zcopy, zlacpy, zptcon, zptrfs,
268  \$ zpttrf, zpttrs
269 * ..
270 * .. Intrinsic Functions ..
271  INTRINSIC max
272 * ..
273 * .. Executable Statements ..
274 *
275 * Test the input parameters.
276 *
277  info = 0
278  nofact = lsame( fact, 'N' )
279  IF( .NOT.nofact .AND. .NOT.lsame( fact, 'F' ) ) THEN
280  info = -1
281  ELSE IF( n.LT.0 ) THEN
282  info = -2
283  ELSE IF( nrhs.LT.0 ) THEN
284  info = -3
285  ELSE IF( ldb.LT.max( 1, n ) ) THEN
286  info = -9
287  ELSE IF( ldx.LT.max( 1, n ) ) THEN
288  info = -11
289  END IF
290  IF( info.NE.0 ) THEN
291  CALL xerbla( 'ZPTSVX', -info )
292  RETURN
293  END IF
294 *
295  IF( nofact ) THEN
296 *
297 * Compute the L*D*L**H (or U**H*D*U) factorization of A.
298 *
299  CALL dcopy( n, d, 1, df, 1 )
300  IF( n.GT.1 )
301  \$ CALL zcopy( n-1, e, 1, ef, 1 )
302  CALL zpttrf( n, df, ef, info )
303 *
304 * Return if INFO is non-zero.
305 *
306  IF( info.GT.0 )THEN
307  rcond = zero
308  RETURN
309  END IF
310  END IF
311 *
312 * Compute the norm of the matrix A.
313 *
314  anorm = zlanht( '1', n, d, e )
315 *
316 * Compute the reciprocal of the condition number of A.
317 *
318  CALL zptcon( n, df, ef, anorm, rcond, rwork, info )
319 *
320 * Compute the solution vectors X.
321 *
322  CALL zlacpy( 'Full', n, nrhs, b, ldb, x, ldx )
323  CALL zpttrs( 'Lower', n, nrhs, df, ef, x, ldx, info )
324 *
325 * Use iterative refinement to improve the computed solutions and
326 * compute error bounds and backward error estimates for them.
327 *
328  CALL zptrfs( 'Lower', n, nrhs, d, e, df, ef, b, ldb, x, ldx, ferr,
329  \$ berr, work, rwork, info )
330 *
331 * Set INFO = N+1 if the matrix is singular to working precision.
332 *
333  IF( rcond.LT.dlamch( 'Epsilon' ) )
334  \$ info = n + 1
335 *
336  RETURN
337 *
338 * End of ZPTSVX
339 *
double precision function dlamch(CMACH)
DLAMCH
Definition: dlamch.f:69
subroutine xerbla(SRNAME, INFO)
XERBLA
Definition: xerbla.f:60
logical function lsame(CA, CB)
LSAME
Definition: lsame.f:53
subroutine zcopy(N, ZX, INCX, ZY, INCY)
ZCOPY
Definition: zcopy.f:81
subroutine zlacpy(UPLO, M, N, A, LDA, B, LDB)
ZLACPY copies all or part of one two-dimensional array to another.
Definition: zlacpy.f:103
double precision function zlanht(NORM, N, D, E)
ZLANHT returns the value of the 1-norm, or the Frobenius norm, or the infinity norm,...
Definition: zlanht.f:101
subroutine zpttrs(UPLO, N, NRHS, D, E, B, LDB, INFO)
ZPTTRS
Definition: zpttrs.f:121
subroutine zptrfs(UPLO, N, NRHS, D, E, DF, EF, B, LDB, X, LDX, FERR, BERR, WORK, RWORK, INFO)
ZPTRFS
Definition: zptrfs.f:183
subroutine zpttrf(N, D, E, INFO)
ZPTTRF
Definition: zpttrf.f:92
subroutine zptcon(N, D, E, ANORM, RCOND, RWORK, INFO)
ZPTCON
Definition: zptcon.f:119
subroutine dcopy(N, DX, INCX, DY, INCY)
DCOPY
Definition: dcopy.f:82
Here is the call graph for this function:
Here is the caller graph for this function: