dgtt01()

subroutine dgtt01	(	integer	n,
		double precision, dimension( * )	dl,
		double precision, dimension( * )	d,
		double precision, dimension( * )	du,
		double precision, dimension( * )	dlf,
		double precision, dimension( * )	df,
		double precision, dimension( * )	duf,
		double precision, dimension( * )	du2,
		integer, dimension( * )	ipiv,
		double precision, dimension( ldwork, * )	work,
		integer	ldwork,
		double precision, dimension( * )	rwork,
		double precision	resid )

DGTT01

Purpose:

!>
!> DGTT01 reconstructs a tridiagonal matrix A from its LU factorization
!> and computes the residual
!>    norm(L*U - A) / ( norm(A) * EPS ),
!> where EPS is the machine epsilon.
!> 

Parameters

[in]	N	!> N is INTEGER !> The order of the matrix A. N >= 0. !>
[in]	DL	!> DL is DOUBLE PRECISION array, dimension (N-1) !> The (n-1) sub-diagonal elements of A. !>
[in]	D	!> D is DOUBLE PRECISION array, dimension (N) !> The diagonal elements of A. !>
[in]	DU	!> DU is DOUBLE PRECISION array, dimension (N-1) !> The (n-1) super-diagonal elements of A. !>
[in]	DLF	!> DLF is DOUBLE PRECISION array, dimension (N-1) !> The (n-1) multipliers that define the matrix L from the !> LU factorization of A. !>
[in]	DF	!> DF is DOUBLE PRECISION array, dimension (N) !> The n diagonal elements of the upper triangular matrix U from !> the LU factorization of A. !>
[in]	DUF	!> DUF is DOUBLE PRECISION array, dimension (N-1) !> The (n-1) elements of the first super-diagonal of U. !>
[in]	DU2	!> DU2 is DOUBLE PRECISION array, dimension (N-2) !> The (n-2) elements of the second super-diagonal of U. !>
[in]	IPIV	!> IPIV is INTEGER array, dimension (N) !> The pivot indices; for 1 <= i <= n, row i of the matrix was !> interchanged with row IPIV(i). IPIV(i) will always be either !> i or i+1; IPIV(i) = i indicates a row interchange was not !> required. !>
[out]	WORK	!> WORK is DOUBLE PRECISION array, dimension (LDWORK,N) !>
[in]	LDWORK	!> LDWORK is INTEGER !> The leading dimension of the array WORK. LDWORK >= max(1,N). !>
[out]	RWORK	!> RWORK is DOUBLE PRECISION array, dimension (N) !>
[out]	RESID	!> RESID is DOUBLE PRECISION !> The scaled residual: norm(L*U - A) / (norm(A) * EPS) !>

Author

Univ. of Tennessee

Univ. of California Berkeley

Univ. of Colorado Denver

NAG Ltd.

Definition at line 132 of file dgtt01.f.

*
*  -- LAPACK test routine --
*  -- LAPACK is a software package provided by Univ. of Tennessee,    --
*  -- Univ. of California Berkeley, Univ. of Colorado Denver and NAG Ltd..--
*
*     .. Scalar Arguments ..
      INTEGER            LDWORK, N
      DOUBLE PRECISION   RESID
*     ..
*     .. Array Arguments ..
      INTEGER            IPIV( * )
      DOUBLE PRECISION   D( * ), DF( * ), DL( * ), DLF( * ), DU( * ),
     $                   DU2( * ), DUF( * ), RWORK( * ),
     $                   WORK( LDWORK, * )
*     ..
*
*  =====================================================================
*
*     .. Parameters ..
      DOUBLE PRECISION   ONE, ZERO
      parameter( one = 1.0d+0, zero = 0.0d+0 )
*     ..
*     .. Local Scalars ..
      INTEGER            I, IP, J, LASTJ
      DOUBLE PRECISION   ANORM, EPS, LI
*     ..
*     .. External Functions ..
      DOUBLE PRECISION   DLAMCH, DLANGT, DLANHS
      EXTERNAL           dlamch, dlangt, dlanhs
*     ..
*     .. Intrinsic Functions ..
      INTRINSIC          min
*     ..
*     .. External Subroutines ..
      EXTERNAL           daxpy, dswap
*     ..
*     .. Executable Statements ..
*
*     Quick return if possible
*
      IF( n.LE.0 ) THEN
         resid = zero
         RETURN
      END IF
*
      eps = dlamch( 'Epsilon' )
*
*     Copy the matrix U to WORK.
*
      DO 20 j = 1, n
         DO 10 i = 1, n
            work( i, j ) = zero
   10    CONTINUE
   20 CONTINUE
      DO 30 i = 1, n
         IF( i.EQ.1 ) THEN
            work( i, i ) = df( i )
            IF( n.GE.2 )
     $         work( i, i+1 ) = duf( i )
            IF( n.GE.3 )
     $         work( i, i+2 ) = du2( i )
         ELSE IF( i.EQ.n ) THEN
            work( i, i ) = df( i )
         ELSE
            work( i, i ) = df( i )
            work( i, i+1 ) = duf( i )
            IF( i.LT.n-1 )
     $         work( i, i+2 ) = du2( i )
         END IF
   30 CONTINUE
*
*     Multiply on the left by L.
*
      lastj = n
      DO 40 i = n - 1, 1, -1
         li = dlf( i )
         CALL daxpy( lastj-i+1, li, work( i, i ), ldwork,
     $               work( i+1, i ), ldwork )
         ip = ipiv( i )
         IF( ip.EQ.i ) THEN
            lastj = min( i+2, n )
         ELSE
            CALL dswap( lastj-i+1, work( i, i ), ldwork, work( i+1, i ),
     $                  ldwork )
         END IF
   40 CONTINUE
*
*     Subtract the matrix A.
*
      work( 1, 1 ) = work( 1, 1 ) - d( 1 )
      IF( n.GT.1 ) THEN
         work( 1, 2 ) = work( 1, 2 ) - du( 1 )
         work( n, n-1 ) = work( n, n-1 ) - dl( n-1 )
         work( n, n ) = work( n, n ) - d( n )
         DO 50 i = 2, n - 1
            work( i, i-1 ) = work( i, i-1 ) - dl( i-1 )
            work( i, i ) = work( i, i ) - d( i )
            work( i, i+1 ) = work( i, i+1 ) - du( i )
   50    CONTINUE
      END IF
*
*     Compute the 1-norm of the tridiagonal matrix A.
*
      anorm = dlangt( '1', n, dl, d, du )
*
*     Compute the 1-norm of WORK, which is only guaranteed to be
*     upper Hessenberg.
*
      resid = dlanhs( '1', n, work, ldwork, rwork )
*
*     Compute norm(L*U - A) / (norm(A) * EPS)
*
      IF( anorm.LE.zero ) THEN
         IF( resid.NE.zero )
     $      resid = one / eps
      ELSE
         resid = ( resid / anorm ) / eps
      END IF
*
      RETURN
*
*     End of DGTT01
*

Here is the call graph for this function:

Here is the caller graph for this function: