Integer, Intent (In)	::	n
Integer, Intent (Inout)	::	ifail
Integer, Intent (Out)	::	ipiv(n)
Real (Kind=nag_wp), Intent (In)	::	lambda, tol
Real (Kind=nag_wp), Intent (Inout)	::	a(n), b(n), c(n)
Real (Kind=nag_wp), Intent (Out)	::	d(n)

C Header Interface

#include nagmk26.h

void	f01lef_ ( const Integer n, double a[], const double lambda, double b[], double c[], const double tol, double d[], Integer ipiv[], Integer ifail)

3

Description

The matrix

T - λ I

, where

T

is a real

n

n

tridiagonal matrix, is factorized as

T - λ I = P L U,

where

P

is a permutation matrix,

L

is a unit lower triangular matrix with at most one nonzero subdiagonal element per column, and

U

is an upper triangular matrix with at most two nonzero superdiagonal elements per column.

The factorization is obtained by Gaussian elimination with partial pivoting and implicit row scaling.

An indication of whether or not the matrix

T - λ I

is nearly singular is returned in the

n

th element of the array ipiv. If it is important that

T - λ I

is nonsingular, as is usually the case when solving a system of tridiagonal equations, then it is strongly recommended that

ipiv (n)

is inspected on return from f01lef. (See the argument ipiv and Section 9 for further details.)

The argument

λ

is included in the routine so that f01lef may be used, in conjunction with f04lef, to obtain eigenvectors of

T

by inverse iteration.

4

References

Wilkinson J H (1965) The Algebraic Eigenvalue Problem Oxford University Press, Oxford

Wilkinson J H and Reinsch C (1971) Handbook for Automatic Computation II, Linear Algebra Springer–Verlag

5

Arguments

1: $n$ – IntegerInput: On entry: $n$ , the order of the matrix $T$ .

Constraint: $n \geq 1$ .
2: $a (n)$ – Real (Kind=nag_wp) arrayInput/Output: On entry: the diagonal elements of $T$ .

On exit: the diagonal elements of the upper triangular matrix $U$ .
3: $lambda$ – Real (Kind=nag_wp)Input: On entry: the scalar $λ$ . f01lef factorizes $T - λ I$ .
4: $b (n)$ – Real (Kind=nag_wp) arrayInput/Output: On entry: the superdiagonal elements of $T$ , stored in $b (2)$ to $b (n)$ ; $b (1)$ is not used.

On exit: the elements of the first superdiagonal of $U$ , stored in $b (2)$ to $b (n)$ .
5: $c (n)$ – Real (Kind=nag_wp) arrayInput/Output: On entry: the subdiagonal elements of $T$ , stored in $c (2)$ to $c (n)$ ; $c (1)$ is not used.

On exit: the subdiagonal elements of $L$ , stored in $c (2)$ to $c (n)$ .
6: $tol$ – Real (Kind=nag_wp)Input: On entry: a relative tolerance used to indicate whether or not the matrix ( $T - λ I$ ) is nearly singular. tol should normally be chosen as approximately the largest relative error in the elements of $T$ . For example, if the elements of $T$ are correct to about $4$ significant figures, then tol should be set to about $5 \times 10^{- 4}$ . See Section 9 for further details on how tol is used. If tol is supplied as less than $ε$ , where $ε$ is the machine precision, then the value $ε$ is used in place of tol.
7: $d (n)$ – Real (Kind=nag_wp) arrayOutput: On exit: the elements of the second superdiagonal of $U$ , stored in $d (3)$ to $d (n)$ ; $d (1)$ and $d (2)$ are not used.
8: $ipiv (n)$ – Integer arrayOutput: On exit: details of the permutation matrix $P$ . If an interchange occurred at the $k$ th step of the elimination, then $ipiv (k) = 1$ , otherwise $ipiv (k) = 0$ . If a diagonal element of $U$ is small, indicating that $(T - λ I)$ is nearly singular, then the element $ipiv (n)$ is returned as positive. Otherwise $ipiv (n)$ is returned as $0$ . See Section 9 for further details. If the application is such that it is important that $(T - λ I)$ is not nearly singular, then it is strongly recommended that $ipiv (n)$ is inspected on return.
9: $ifail$ – IntegerInput/Output: On entry: ifail must be set to $0$ , $- 1 or 1$ . If you are unfamiliar with this argument you should refer to Section 3.4 in How to Use the NAG Library and its Documentation for details.
For environments where it might be inappropriate to halt program execution when an error is detected, the value $- 1 or 1$ is recommended. If the output of error messages is undesirable, then the value $1$ is recommended. Otherwise, if you are not familiar with this argument, the recommended value is $0$ . When the value $- 1 or 1$ is used it is essential to test the value of ifail on exit.

On exit: $ifail = 0$ unless the routine detects an error or a warning has been flagged (see Section 6).

6

Error Indicators and Warnings

If on entry

ifail = 0

- 1

, explanatory error messages are output on the current error message unit (as defined by x04aaf).

Errors or warnings detected by the routine:

$ifail = 1$

On entry,

n < 1

$ifail = - 99$: An unexpected error has been triggered by this routine. Please contact NAG.
See Section 3.9 in How to Use the NAG Library and its Documentation for further information.

$ifail = - 399$: Your licence key may have expired or may not have been installed correctly.
See Section 3.8 in How to Use the NAG Library and its Documentation for further information.

$ifail = - 999$: Dynamic memory allocation failed.
See Section 3.7 in How to Use the NAG Library and its Documentation for further information.

7

Accuracy

The computed factorization will satisfy the equation

P L U = (T - λ I) + E,

where

{‖E‖}_{1} \leq 9 \times \max_{i \geq j} (|l_{i j}|, {|l_{i j}|}^{2}) ε {‖T - λ I‖}_{1}

where

ε

is the machine precision.

8

Parallelism and Performance

f01lef makes calls to BLAS and/or LAPACK routines, which may be threaded within the vendor library used by this implementation. Consult the documentation for the vendor library for further information.

Please consult the X06 Chapter Introduction for information on how to control and interrogate the OpenMP environment used within this routine. Please also consult the Users' Note for your implementation for any additional implementation-specific information.

9

Further Comments

The time taken by f01lef is approximately proportional to

n

The factorization of a tridiagonal matrix proceeds in

(n - 1)

steps, each step eliminating one subdiagonal element of the tridiagonal matrix. In order to avoid small pivot elements and to prevent growth in the size of the elements of

L

, rows

k

and (

k + 1

) will, if necessary, be interchanged at the

k

th step prior to the elimination.

The element

ipiv (n)

returns the smallest integer,

j

, for which

|u_{j j}| \leq {‖{(T - λ I)}_{j}‖}_{1} \times tol,

where

{‖{(T - λ I)}_{j}‖}_{1}

denotes the sum of the absolute values of the

j

th row of the matrix (

T - λ I

). If no such

j

exists, then

ipiv (n)

is returned as zero. If such a

j

exists, then

|u_{j j}|

is small and hence (

T - λ I

) is singular or nearly singular.

This routine may be followed by f04lef to solve systems of tridiagonal equations. If you wish to solve single systems of tridiagonal equations you should be aware of f07caf (dgtsv), which solves tridiagonal systems with a single call. f07caf (dgtsv) requires less storage and will generally be faster than the combination of f01lef and f04lef, but no test for near singularity is included in f07caf (dgtsv) and so it should only be used when the equations are known to be nonsingular.

10

Example

This example factorizes the tridiagonal matrix

T

where

T = (\begin{array}{r} 3.0 & 2.1 & 0 & 0 & 0 \\ 3.4 & 2.3 & - 1.0 & 0 & 0 \\ 0 & 3.6 & - 5.0 & 1.9 & 0 \\ 0 & 0 & 7.0 & - 0.9 & 8.0 \\ 0 & 0 & 0 & - 6.0 & 7.1 \end{array})

and then to solve the equations

T x = y

, where

y = (\begin{array}{r} 2.7 \\ - 0.5 \\ 2.6 \\ 0.6 \\ 2.7 \end{array})

by a call to f04lef. The example program sets

tol = 5 \times 10^{- 5}

and, of course, sets

lambda = 0

NAG Library Routine Document

f01lef (real_gen_tridiag_lu)

▸▿ Contents

1 Purpose

2 Specification

3 Description

4 References

5 Arguments

6 Error Indicators and Warnings

7 Accuracy

8 Parallelism and Performance

9 Further Comments

10 Example

10.1 Program Text

10.2 Program Data

10.3 Program Results

1

Purpose

2

Specification

3

Description

4

References

5

Arguments

6

Error Indicators and Warnings

7

Accuracy

8

Parallelism and Performance

9

Further Comments

10

Example

10.1

Program Text

10.2

Program Data

10.3

Program Results