lagtf(3)

NAME
lagtf - lagtf: LU factor of (T - λI)

SYNOPSIS

  Functions

subroutine dlagtf (n, a, lambda, b, c, tol, d, in, info)
DLAGTF computes an LU factorization of a matrix T-λI, where T is a general tridiagonal matrix, and λ a scalar, using partial pivoting with row interchanges.
subroutine slagtf (n, a, lambda, b, c, tol, d, in, info)
SLAGTF computes an LU factorization of a matrix T-λI, where T is a general tridiagonal matrix, and λ a scalar, using partial pivoting with row interchanges.

Detailed Description

Function Documentation

  subroutine dlagtf (integer n, double precision, dimension( * ) a, double precision lambda, double precision, dimension( * ) b, double precision, dimension( * ) c, double precision tol, double precision, dimension( * ) d, integer, dimension( * ) in, integer info)

DLAGTF computes an LU factorization of a matrix T-λI, where T is a general tridiagonal matrix, and λ a scalar, using partial pivoting with row interchanges.

Purpose:

    !>
    !> DLAGTF factorizes the matrix (T - lambda*I), where T is an n by n
    !> tridiagonal matrix and lambda is a scalar, as
    !>
    !>    T - lambda*I = PLU,
    !>
    !> where P is a permutation matrix, L is a unit lower tridiagonal matrix
    !> with at most one non-zero sub-diagonal elements per column and U is
    !> an upper triangular matrix with at most two non-zero super-diagonal
    !> elements per column.
    !>
    !> The factorization is obtained by Gaussian elimination with partial
    !> pivoting and implicit row scaling.
    !>
    !> The parameter LAMBDA is included in the routine so that DLAGTF may
    !> be used, in conjunction with DLAGTS, to obtain eigenvectors of T by
    !> inverse iteration.
    !>

Parameters
    N

    !>          N is INTEGER
    !>          The order of the matrix T.
    !>

    A

    !>          A is DOUBLE PRECISION array, dimension (N)
    !>          On entry, A must contain the diagonal elements of T.
    !>
    !>          On exit, A is overwritten by the n diagonal elements of the
    !>          upper triangular matrix U of the factorization of T.
    !>

    LAMBDA

    !>          LAMBDA is DOUBLE PRECISION
    !>          On entry, the scalar lambda.
    !>

    B

    !>          B is DOUBLE PRECISION array, dimension (N-1)
    !>          On entry, B must contain the (n-1) super-diagonal elements of
    !>          T.
    !>
    !>          On exit, B is overwritten by the (n-1) super-diagonal
    !>          elements of the matrix U of the factorization of T.
    !>

    C

    !>          C is DOUBLE PRECISION array, dimension (N-1)
    !>          On entry, C must contain the (n-1) sub-diagonal elements of
    !>          T.
    !>
    !>          On exit, C is overwritten by the (n-1) sub-diagonal elements
    !>          of the matrix L of the factorization of T.
    !>

    TOL

    !>          TOL is DOUBLE PRECISION
    !>          On entry, a relative tolerance used to indicate whether or
    !>          not the matrix (T - lambda*I) is nearly singular. TOL should
    !>          normally be chose 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*10**(-4). If TOL is supplied as less than eps,
    !>          where eps is the relative machine precision, then the value
    !>          eps is used in place of TOL.
    !>

    D

    !>          D is DOUBLE PRECISION array, dimension (N-2)
    !>          On exit, D is overwritten by the (n-2) second super-diagonal
    !>          elements of the matrix U of the factorization of T.
    !>

    IN

    !>          IN is INTEGER array, dimension (N)
    !>          On exit, IN contains details of the permutation matrix P. If
    !>          an interchange occurred at the kth step of the elimination,
    !>          then IN(k) = 1, otherwise IN(k) = 0. The element IN(n)
    !>          returns the smallest positive integer j such that
    !>
    !>             abs( u(j,j) ) <= norm( (T - lambda*I)(j) )*TOL,
    !>
    !>          where norm( A(j) ) denotes the sum of the absolute values of
    !>          the jth row of the matrix A. If no such j exists then IN(n)
    !>          is returned as zero. If IN(n) is returned as positive, then a
    !>          diagonal element of U is small, indicating that
    !>          (T - lambda*I) is singular or nearly singular,
    !>

    INFO

    !>          INFO is INTEGER
    !>          = 0:  successful exit
    !>          < 0:  if INFO = -k, the kth argument had an illegal value
    !>

Author
    Univ. of Tennessee

    Univ. of California Berkeley

    Univ. of Colorado Denver

    NAG Ltd.

  subroutine slagtf (integer n, real, dimension( * ) a, real lambda, real, dimension( * ) b, real, dimension( * ) c, real tol, real, dimension( * ) d, integer, dimension( * ) in, integer info)

SLAGTF computes an LU factorization of a matrix T-λI, where T is a general tridiagonal matrix, and λ a scalar, using partial pivoting with row interchanges.

Purpose:

    !>
    !> SLAGTF factorizes the matrix (T - lambda*I), where T is an n by n
    !> tridiagonal matrix and lambda is a scalar, as
    !>
    !>    T - lambda*I = PLU,
    !>
    !> where P is a permutation matrix, L is a unit lower tridiagonal matrix
    !> with at most one non-zero sub-diagonal elements per column and U is
    !> an upper triangular matrix with at most two non-zero super-diagonal
    !> elements per column.
    !>
    !> The factorization is obtained by Gaussian elimination with partial
    !> pivoting and implicit row scaling.
    !>
    !> The parameter LAMBDA is included in the routine so that SLAGTF may
    !> be used, in conjunction with SLAGTS, to obtain eigenvectors of T by
    !> inverse iteration.
    !>

Parameters
    N

    !>          N is INTEGER
    !>          The order of the matrix T.
    !>

    A

    !>          A is REAL array, dimension (N)
    !>          On entry, A must contain the diagonal elements of T.
    !>
    !>          On exit, A is overwritten by the n diagonal elements of the
    !>          upper triangular matrix U of the factorization of T.
    !>

    LAMBDA

    !>          LAMBDA is REAL
    !>          On entry, the scalar lambda.
    !>

    B

    !>          B is REAL array, dimension (N-1)
    !>          On entry, B must contain the (n-1) super-diagonal elements of
    !>          T.
    !>
    !>          On exit, B is overwritten by the (n-1) super-diagonal
    !>          elements of the matrix U of the factorization of T.
    !>

    C

    !>          C is REAL array, dimension (N-1)
    !>          On entry, C must contain the (n-1) sub-diagonal elements of
    !>          T.
    !>
    !>          On exit, C is overwritten by the (n-1) sub-diagonal elements
    !>          of the matrix L of the factorization of T.
    !>

    TOL

    !>          TOL is REAL
    !>          On entry, a relative tolerance used to indicate whether or
    !>          not the matrix (T - lambda*I) is nearly singular. TOL should
    !>          normally be chose 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*10**(-4). If TOL is supplied as less than eps,
    !>          where eps is the relative machine precision, then the value
    !>          eps is used in place of TOL.
    !>

    D

    !>          D is REAL array, dimension (N-2)
    !>          On exit, D is overwritten by the (n-2) second super-diagonal
    !>          elements of the matrix U of the factorization of T.
    !>

    IN

    !>          IN is INTEGER array, dimension (N)
    !>          On exit, IN contains details of the permutation matrix P. If
    !>          an interchange occurred at the kth step of the elimination,
    !>          then IN(k) = 1, otherwise IN(k) = 0. The element IN(n)
    !>          returns the smallest positive integer j such that
    !>
    !>             abs( u(j,j) ) <= norm( (T - lambda*I)(j) )*TOL,
    !>
    !>          where norm( A(j) ) denotes the sum of the absolute values of
    !>          the jth row of the matrix A. If no such j exists then IN(n)
    !>          is returned as zero. If IN(n) is returned as positive, then a
    !>          diagonal element of U is small, indicating that
    !>          (T - lambda*I) is singular or nearly singular,
    !>

    INFO

    !>          INFO is INTEGER
    !>          = 0: successful exit
    !>          < 0: if INFO = -k, the kth argument had an illegal value
    !>

Author
    Univ. of Tennessee

    Univ. of California Berkeley

    Univ. of Colorado Denver

    NAG Ltd.

Author

Generated automatically by Doxygen for LAPACK from the source code.