Loading...
Searching...
No Matches

## slagtf()

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.

Download SLAGTF + dependencies [TGZ] [ZIP] [TXT]

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

  [in]

  N

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

  [in,out]

  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.
      !>

  [in]

  LAMBDA

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

  [in,out]

  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.
      !>

  [in,out]

  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.
      !>

  [in]

  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.
      !>

  [out]

  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.
      !>

  [out]

  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,
      !>

  [out]

  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.