subroutine ssyt01_rook	(	character	UPLO,
		integer	N,
		real, dimension( lda, * )	A,
		integer	LDA,
		real, dimension( ldafac, * )	AFAC,
		integer	LDAFAC,
		integer, dimension( * )	IPIV,
		real, dimension( ldc, * )	C,
		integer	LDC,
		real, dimension( * )	RWORK,
		real	RESID
	)

SSYT01_ROOK

Purpose:

 SSYT01_ROOK reconstructs a symmetric indefinite matrix A from its
 block L*D*L' or U*D*U' factorization and computes the residual
    norm( C - A ) / ( N * norm(A) * EPS ),
 where C is the reconstructed matrix and EPS is the machine epsilon.

Parameters

[in]	UPLO	UPLO is CHARACTER*1 Specifies whether the upper or lower triangular part of the symmetric matrix A is stored: = 'U': Upper triangular = 'L': Lower triangular
[in]	N	N is INTEGER The number of rows and columns of the matrix A. N >= 0.
[in]	A	A is REAL array, dimension (LDA,N) The original symmetric matrix A.
[in]	LDA	LDA is INTEGER The leading dimension of the array A. LDA >= max(1,N)
[in]	AFAC	AFAC is REAL array, dimension (LDAFAC,N) The factored form of the matrix A. AFAC contains the block diagonal matrix D and the multipliers used to obtain the factor L or U from the block L*D*L' or U*D*U' factorization as computed by SSYTRF_ROOK.
[in]	LDAFAC	LDAFAC is INTEGER The leading dimension of the array AFAC. LDAFAC >= max(1,N).
[in]	IPIV	IPIV is INTEGER array, dimension (N) The pivot indices from SSYTRF_ROOK.
[out]	C	C is REAL array, dimension (LDC,N)
[in]	LDC	LDC is INTEGER The leading dimension of the array C. LDC >= max(1,N).
[out]	RWORK	RWORK is REAL array, dimension (N)
[out]	RESID	RESID is REAL If UPLO = 'L', norm(L*D*L' - A) / ( N * norm(A) * EPS ) If UPLO = 'U', norm(U*D*U' - A) / ( N * norm(A) * EPS )

Author

Univ. of Tennessee

Univ. of California Berkeley

Univ. of Colorado Denver

NAG Ltd.

Date

November 2013

Definition at line 126 of file ssyt01_rook.f.

*
*  -- LAPACK test routine (version 3.5.0) --
*  -- LAPACK is a software package provided by Univ. of Tennessee,    --
*  -- Univ. of California Berkeley, Univ. of Colorado Denver and NAG Ltd..--
*     November 2013
*
*     .. Scalar Arguments ..
      CHARACTER          uplo
      INTEGER            lda, ldafac, ldc, n
      REAL               resid
*     ..
*     .. Array Arguments ..
      INTEGER            ipiv( * )
      REAL               a( lda, * ), afac( ldafac, * ), c( ldc, * ),
     $                   rwork( * )
*     ..
*
*  =====================================================================
*
*     .. Parameters ..
      REAL               zero, one
      parameter                ( zero = 0.0e+0, one = 1.0e+0 )
*     ..
*     .. Local Scalars ..
      INTEGER            i, info, j
      REAL               anorm, eps
*     ..
*     .. External Functions ..
      LOGICAL            lsame
      REAL               slamch, slansy
      EXTERNAL           lsame, slamch, slansy
*     ..
*     .. External Subroutines ..
      EXTERNAL           slaset, slavsy_rook
*     ..
*     .. Intrinsic Functions ..
      INTRINSIC          real
*     ..
*     .. Executable Statements ..
*
*     Quick exit if N = 0.
*
      IF( n.LE.0 ) THEN
         resid = zero
         RETURN
      END IF
*
*     Determine EPS and the norm of A.
*
      eps = slamch( 'Epsilon' )
      anorm = slansy( '1', uplo, n, a, lda, rwork )
*
*     Initialize C to the identity matrix.
*
      CALL slaset( 'Full', n, n, zero, one, c, ldc )
*
*     Call SLAVSY_ROOK to form the product D * U' (or D * L' ).
*
      CALL slavsy_rook( uplo, 'Transpose', 'Non-unit', n, n, afac,
     $              ldafac, ipiv, c, ldc, info )
*
*     Call SLAVSY_ROOK again to multiply by U (or L ).
*
      CALL slavsy_rook( uplo, 'No transpose', 'Unit', n, n, afac,
     $              ldafac, ipiv, c, ldc, info )
*
*     Compute the difference  C - A .
*
      IF( lsame( uplo, 'U' ) ) THEN
         DO 20 j = 1, n
            DO 10 i = 1, j
               c( i, j ) = c( i, j ) - a( i, j )
   10       CONTINUE
   20    CONTINUE
      ELSE
         DO 40 j = 1, n
            DO 30 i = j, n
               c( i, j ) = c( i, j ) - a( i, j )
   30       CONTINUE
   40    CONTINUE
      END IF
*
*     Compute norm( C - A ) / ( N * norm(A) * EPS )
*
      resid = slansy( '1', uplo, n, c, ldc, rwork )
*
      IF( anorm.LE.zero ) THEN
         IF( resid.NE.zero )
     $      resid = one / eps
      ELSE
         resid = ( ( resid / REAL( N ) ) / anorm ) / eps
      END IF
*
      RETURN
*
*     End of SSYT01_ROOK
*

Here is the call graph for this function:

Here is the caller graph for this function: