subroutine cherfs	(	character	UPLO,
		integer	N,
		integer	NRHS,
		complex, dimension( lda, * )	A,
		integer	LDA,
		complex, dimension( ldaf, * )	AF,
		integer	LDAF,
		integer, dimension( * )	IPIV,
		complex, dimension( ldb, * )	B,
		integer	LDB,
		complex, dimension( ldx, * )	X,
		integer	LDX,
		real, dimension( * )	FERR,
		real, dimension( * )	BERR,
		complex, dimension( * )	WORK,
		real, dimension( * )	RWORK,
		integer	INFO
	)

CHERFS

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

Purpose:

 CHERFS improves the computed solution to a system of linear
 equations when the coefficient matrix is Hermitian indefinite, and
 provides error bounds and backward error estimates for the solution.

Parameters

[in]	UPLO	UPLO is CHARACTER*1 = 'U': Upper triangle of A is stored; = 'L': Lower triangle of A is stored.
[in]	N	N is INTEGER The order of the matrix A. N >= 0.
[in]	NRHS	NRHS is INTEGER The number of right hand sides, i.e., the number of columns of the matrices B and X. NRHS >= 0.
[in]	A	A is COMPLEX array, dimension (LDA,N) The Hermitian matrix A. If UPLO = 'U', the leading N-by-N upper triangular part of A contains the upper triangular part of the matrix A, and the strictly lower triangular part of A is not referenced. If UPLO = 'L', the leading N-by-N lower triangular part of A contains the lower triangular part of the matrix A, and the strictly upper triangular part of A is not referenced.
[in]	LDA	LDA is INTEGER The leading dimension of the array A. LDA >= max(1,N).
[in]	AF	AF is COMPLEX array, dimension (LDAF,N) The factored form of the matrix A. AF contains the block diagonal matrix D and the multipliers used to obtain the factor U or L from the factorization A = U*D*U**H or A = L*D*L**H as computed by CHETRF.
[in]	LDAF	LDAF is INTEGER The leading dimension of the array AF. LDAF >= max(1,N).
[in]	IPIV	IPIV is INTEGER array, dimension (N) Details of the interchanges and the block structure of D as determined by CHETRF.
[in]	B	B is COMPLEX array, dimension (LDB,NRHS) The right hand side matrix B.
[in]	LDB	LDB is INTEGER The leading dimension of the array B. LDB >= max(1,N).
[in,out]	X	X is COMPLEX array, dimension (LDX,NRHS) On entry, the solution matrix X, as computed by CHETRS. On exit, the improved solution matrix X.
[in]	LDX	LDX is INTEGER The leading dimension of the array X. LDX >= max(1,N).
[out]	FERR	FERR is REAL array, dimension (NRHS) The estimated forward error bound for each solution vector X(j) (the j-th column of the solution matrix X). If XTRUE is the true solution corresponding to X(j), FERR(j) is an estimated upper bound for the magnitude of the largest element in (X(j) - XTRUE) divided by the magnitude of the largest element in X(j). The estimate is as reliable as the estimate for RCOND, and is almost always a slight overestimate of the true error.
[out]	BERR	BERR is REAL array, dimension (NRHS) The componentwise relative backward error of each solution vector X(j) (i.e., the smallest relative change in any element of A or B that makes X(j) an exact solution).
[out]	WORK	WORK is COMPLEX array, dimension (2*N)
[out]	RWORK	RWORK is REAL array, dimension (N)
[out]	INFO	INFO is INTEGER = 0: successful exit < 0: if INFO = -i, the i-th argument had an illegal value

Internal Parameters:

  ITMAX is the maximum number of steps of iterative refinement.

Author

Univ. of Tennessee

Univ. of California Berkeley

Univ. of Colorado Denver

NAG Ltd.

Date

November 2011

Definition at line 194 of file cherfs.f.

*
*  -- LAPACK computational routine (version 3.4.0) --
*  -- LAPACK is a software package provided by Univ. of Tennessee,    --
*  -- Univ. of California Berkeley, Univ. of Colorado Denver and NAG Ltd..--
*     November 2011
*
*     .. Scalar Arguments ..
      CHARACTER          uplo
      INTEGER            info, lda, ldaf, ldb, ldx, n, nrhs
*     ..
*     .. Array Arguments ..
      INTEGER            ipiv( * )
      REAL               berr( * ), ferr( * ), rwork( * )
      COMPLEX            a( lda, * ), af( ldaf, * ), b( ldb, * ),
     $                   work( * ), x( ldx, * )
*     ..
*
*  =====================================================================
*
*     .. Parameters ..
      INTEGER            itmax
      parameter                ( itmax = 5 )
      REAL               zero
      parameter                ( zero = 0.0e+0 )
      COMPLEX            one
      parameter                ( one = ( 1.0e+0, 0.0e+0 ) )
      REAL               two
      parameter                ( two = 2.0e+0 )
      REAL               three
      parameter                ( three = 3.0e+0 )
*     ..
*     .. Local Scalars ..
      LOGICAL            upper
      INTEGER            count, i, j, k, kase, nz
      REAL               eps, lstres, s, safe1, safe2, safmin, xk
      COMPLEX            zdum
*     ..
*     .. Local Arrays ..
      INTEGER            isave( 3 )
*     ..
*     .. External Subroutines ..
      EXTERNAL           caxpy, ccopy, chemv, chetrs, clacn2, xerbla
*     ..
*     .. Intrinsic Functions ..
      INTRINSIC          abs, aimag, max, real
*     ..
*     .. External Functions ..
      LOGICAL            lsame
      REAL               slamch
      EXTERNAL           lsame, slamch
*     ..
*     .. Statement Functions ..
      REAL               cabs1
*     ..
*     .. Statement Function definitions ..
      cabs1( zdum ) = abs( REAL( ZDUM ) ) + abs( aimag( zdum ) )
*     ..
*     .. Executable Statements ..
*
*     Test the input parameters.
*
      info = 0
      upper = lsame( uplo, 'U' )
      IF( .NOT.upper .AND. .NOT.lsame( uplo, 'L' ) ) THEN
         info = -1
      ELSE IF( n.LT.0 ) THEN
         info = -2
      ELSE IF( nrhs.LT.0 ) THEN
         info = -3
      ELSE IF( lda.LT.max( 1, n ) ) THEN
         info = -5
      ELSE IF( ldaf.LT.max( 1, n ) ) THEN
         info = -7
      ELSE IF( ldb.LT.max( 1, n ) ) THEN
         info = -10
      ELSE IF( ldx.LT.max( 1, n ) ) THEN
         info = -12
      END IF
      IF( info.NE.0 ) THEN
         CALL xerbla( 'CHERFS', -info )
         RETURN
      END IF
*
*     Quick return if possible
*
      IF( n.EQ.0 .OR. nrhs.EQ.0 ) THEN
         DO 10 j = 1, nrhs
            ferr( j ) = zero
            berr( j ) = zero
   10    CONTINUE
         RETURN
      END IF
*
*     NZ = maximum number of nonzero elements in each row of A, plus 1
*
      nz = n + 1
      eps = slamch( 'Epsilon' )
      safmin = slamch( 'Safe minimum' )
      safe1 = nz*safmin
      safe2 = safe1 / eps
*
*     Do for each right hand side
*
      DO 140 j = 1, nrhs
*
         count = 1
         lstres = three
   20    CONTINUE
*
*        Loop until stopping criterion is satisfied.
*
*        Compute residual R = B - A * X
*
         CALL ccopy( n, b( 1, j ), 1, work, 1 )
         CALL chemv( uplo, n, -one, a, lda, x( 1, j ), 1, one, work, 1 )
*
*        Compute componentwise relative backward error from formula
*
*        max(i) ( abs(R(i)) / ( abs(A)*abs(X) + abs(B) )(i) )
*
*        where abs(Z) is the componentwise absolute value of the matrix
*        or vector Z.  If the i-th component of the denominator is less
*        than SAFE2, then SAFE1 is added to the i-th components of the
*        numerator and denominator before dividing.
*
         DO 30 i = 1, n
            rwork( i ) = cabs1( b( i, j ) )
   30    CONTINUE
*
*        Compute abs(A)*abs(X) + abs(B).
*
         IF( upper ) THEN
            DO 50 k = 1, n
               s = zero
               xk = cabs1( x( k, j ) )
               DO 40 i = 1, k - 1
                  rwork( i ) = rwork( i ) + cabs1( a( i, k ) )*xk
                  s = s + cabs1( a( i, k ) )*cabs1( x( i, j ) )
   40          CONTINUE
               rwork( k ) = rwork( k ) + abs( REAL( A( K, K ) ) )*xk + s
   50       CONTINUE
         ELSE
            DO 70 k = 1, n
               s = zero
               xk = cabs1( x( k, j ) )
               rwork( k ) = rwork( k ) + abs( REAL( A( K, K ) ) )*xk
               DO 60 i = k + 1, n
                  rwork( i ) = rwork( i ) + cabs1( a( i, k ) )*xk
                  s = s + cabs1( a( i, k ) )*cabs1( x( i, j ) )
   60          CONTINUE
               rwork( k ) = rwork( k ) + s
   70       CONTINUE
         END IF
         s = zero
         DO 80 i = 1, n
            IF( rwork( i ).GT.safe2 ) THEN
               s = max( s, cabs1( work( i ) ) / rwork( i ) )
            ELSE
               s = max( s, ( cabs1( work( i ) )+safe1 ) /
     $             ( rwork( i )+safe1 ) )
            END IF
   80    CONTINUE
         berr( j ) = s
*
*        Test stopping criterion. Continue iterating if
*           1) The residual BERR(J) is larger than machine epsilon, and
*           2) BERR(J) decreased by at least a factor of 2 during the
*              last iteration, and
*           3) At most ITMAX iterations tried.
*
         IF( berr( j ).GT.eps .AND. two*berr( j ).LE.lstres .AND.
     $       count.LE.itmax ) THEN
*
*           Update solution and try again.
*
            CALL chetrs( uplo, n, 1, af, ldaf, ipiv, work, n, info )
            CALL caxpy( n, one, work, 1, x( 1, j ), 1 )
            lstres = berr( j )
            count = count + 1
            GO TO 20
         END IF
*
*        Bound error from formula
*
*        norm(X - XTRUE) / norm(X) .le. FERR =
*        norm( abs(inv(A))*
*           ( abs(R) + NZ*EPS*( abs(A)*abs(X)+abs(B) ))) / norm(X)
*
*        where
*          norm(Z) is the magnitude of the largest component of Z
*          inv(A) is the inverse of A
*          abs(Z) is the componentwise absolute value of the matrix or
*             vector Z
*          NZ is the maximum number of nonzeros in any row of A, plus 1
*          EPS is machine epsilon
*
*        The i-th component of abs(R)+NZ*EPS*(abs(A)*abs(X)+abs(B))
*        is incremented by SAFE1 if the i-th component of
*        abs(A)*abs(X) + abs(B) is less than SAFE2.
*
*        Use CLACN2 to estimate the infinity-norm of the matrix
*           inv(A) * diag(W),
*        where W = abs(R) + NZ*EPS*( abs(A)*abs(X)+abs(B) )))
*
         DO 90 i = 1, n
            IF( rwork( i ).GT.safe2 ) THEN
               rwork( i ) = cabs1( work( i ) ) + nz*eps*rwork( i )
            ELSE
               rwork( i ) = cabs1( work( i ) ) + nz*eps*rwork( i ) +
     $                      safe1
            END IF
   90    CONTINUE
*
         kase = 0
  100    CONTINUE
         CALL clacn2( n, work( n+1 ), work, ferr( j ), kase, isave )
         IF( kase.NE.0 ) THEN
            IF( kase.EQ.1 ) THEN
*
*              Multiply by diag(W)*inv(A**H).
*
               CALL chetrs( uplo, n, 1, af, ldaf, ipiv, work, n, info )
               DO 110 i = 1, n
                  work( i ) = rwork( i )*work( i )
  110          CONTINUE
            ELSE IF( kase.EQ.2 ) THEN
*
*              Multiply by inv(A)*diag(W).
*
               DO 120 i = 1, n
                  work( i ) = rwork( i )*work( i )
  120          CONTINUE
               CALL chetrs( uplo, n, 1, af, ldaf, ipiv, work, n, info )
            END IF
            GO TO 100
         END IF
*
*        Normalize error.
*
         lstres = zero
         DO 130 i = 1, n
            lstres = max( lstres, cabs1( x( i, j ) ) )
  130    CONTINUE
         IF( lstres.NE.zero )
     $      ferr( j ) = ferr( j ) / lstres
*
  140 CONTINUE
*
      RETURN
*
*     End of CHERFS
*

Here is the call graph for this function:

Here is the caller graph for this function: