subroutine spprfs	(	character	UPLO,
		integer	N,
		integer	NRHS,
		real, dimension( * )	AP,
		real, dimension( * )	AFP,
		real, dimension( ldb, * )	B,
		integer	LDB,
		real, dimension( ldx, * )	X,
		integer	LDX,
		real, dimension( * )	FERR,
		real, dimension( * )	BERR,
		real, dimension( * )	WORK,
		integer, dimension( * )	IWORK,
		integer	INFO
	)

SPPRFS

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

Purpose:

 SPPRFS improves the computed solution to a system of linear
 equations when the coefficient matrix is symmetric positive definite
 and packed, 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]	AP	AP is REAL array, dimension (N*(N+1)/2) The upper or lower triangle of the symmetric matrix A, packed columnwise in a linear array. The j-th column of A is stored in the array AP as follows: if UPLO = 'U', AP(i + (j-1)*j/2) = A(i,j) for 1<=i<=j; if UPLO = 'L', AP(i + (j-1)*(2n-j)/2) = A(i,j) for j<=i<=n.
[in]	AFP	AFP is REAL array, dimension (N*(N+1)/2) The triangular factor U or L from the Cholesky factorization A = U**T*U or A = L*L**T, as computed by SPPTRF/CPPTRF, packed columnwise in a linear array in the same format as A (see AP).
[in]	B	B is REAL 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 REAL array, dimension (LDX,NRHS) On entry, the solution matrix X, as computed by SPPTRS. 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 REAL array, dimension (3*N)
[out]	IWORK	IWORK is INTEGER 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 173 of file spprfs.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, ldb, ldx, n, nrhs
*     ..
*     .. Array Arguments ..
      INTEGER            iwork( * )
      REAL               afp( * ), ap( * ), b( ldb, * ), berr( * ),
     $                   ferr( * ), work( * ), x( ldx, * )
*     ..
*
*  =====================================================================
*
*     .. Parameters ..
      INTEGER            itmax
      parameter                ( itmax = 5 )
      REAL               zero
      parameter                ( zero = 0.0e+0 )
      REAL               one
      parameter                ( one = 1.0e+0 )
      REAL               two
      parameter                ( two = 2.0e+0 )
      REAL               three
      parameter                ( three = 3.0e+0 )
*     ..
*     .. Local Scalars ..
      LOGICAL            upper
      INTEGER            count, i, ik, j, k, kase, kk, nz
      REAL               eps, lstres, s, safe1, safe2, safmin, xk
*     ..
*     .. Local Arrays ..
      INTEGER            isave( 3 )
*     ..
*     .. External Subroutines ..
      EXTERNAL           saxpy, scopy, slacn2, spptrs, sspmv, xerbla
*     ..
*     .. Intrinsic Functions ..
      INTRINSIC          abs, max
*     ..
*     .. External Functions ..
      LOGICAL            lsame
      REAL               slamch
      EXTERNAL           lsame, slamch
*     ..
*     .. 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( ldb.LT.max( 1, n ) ) THEN
         info = -7
      ELSE IF( ldx.LT.max( 1, n ) ) THEN
         info = -9
      END IF
      IF( info.NE.0 ) THEN
         CALL xerbla( 'SPPRFS', -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 scopy( n, b( 1, j ), 1, work( n+1 ), 1 )
         CALL sspmv( uplo, n, -one, ap, x( 1, j ), 1, one, work( n+1 ),
     $               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
            work( i ) = abs( b( i, j ) )
   30    CONTINUE
*
*        Compute abs(A)*abs(X) + abs(B).
*
         kk = 1
         IF( upper ) THEN
            DO 50 k = 1, n
               s = zero
               xk = abs( x( k, j ) )
               ik = kk
               DO 40 i = 1, k - 1
                  work( i ) = work( i ) + abs( ap( ik ) )*xk
                  s = s + abs( ap( ik ) )*abs( x( i, j ) )
                  ik = ik + 1
   40          CONTINUE
               work( k ) = work( k ) + abs( ap( kk+k-1 ) )*xk + s
               kk = kk + k
   50       CONTINUE
         ELSE
            DO 70 k = 1, n
               s = zero
               xk = abs( x( k, j ) )
               work( k ) = work( k ) + abs( ap( kk ) )*xk
               ik = kk + 1
               DO 60 i = k + 1, n
                  work( i ) = work( i ) + abs( ap( ik ) )*xk
                  s = s + abs( ap( ik ) )*abs( x( i, j ) )
                  ik = ik + 1
   60          CONTINUE
               work( k ) = work( k ) + s
               kk = kk + ( n-k+1 )
   70       CONTINUE
         END IF
         s = zero
         DO 80 i = 1, n
            IF( work( i ).GT.safe2 ) THEN
               s = max( s, abs( work( n+i ) ) / work( i ) )
            ELSE
               s = max( s, ( abs( work( n+i ) )+safe1 ) /
     $             ( work( 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 spptrs( uplo, n, 1, afp, work( n+1 ), n, info )
            CALL saxpy( n, one, work( n+1 ), 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 SLACN2 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( work( i ).GT.safe2 ) THEN
               work( i ) = abs( work( n+i ) ) + nz*eps*work( i )
            ELSE
               work( i ) = abs( work( n+i ) ) + nz*eps*work( i ) + safe1
            END IF
   90    CONTINUE
*
         kase = 0
  100    CONTINUE
         CALL slacn2( n, work( 2*n+1 ), work( n+1 ), iwork, ferr( j ),
     $                kase, isave )
         IF( kase.NE.0 ) THEN
            IF( kase.EQ.1 ) THEN
*
*              Multiply by diag(W)*inv(A**T).
*
               CALL spptrs( uplo, n, 1, afp, work( n+1 ), n, info )
               DO 110 i = 1, n
                  work( n+i ) = work( i )*work( n+i )
  110          CONTINUE
            ELSE IF( kase.EQ.2 ) THEN
*
*              Multiply by inv(A)*diag(W).
*
               DO 120 i = 1, n
                  work( n+i ) = work( i )*work( n+i )
  120          CONTINUE
               CALL spptrs( uplo, n, 1, afp, work( n+1 ), n, info )
            END IF
            GO TO 100
         END IF
*
*        Normalize error.
*
         lstres = zero
         DO 130 i = 1, n
            lstres = max( lstres, abs( x( i, j ) ) )
  130    CONTINUE
         IF( lstres.NE.zero )
     $      ferr( j ) = ferr( j ) / lstres
*
  140 CONTINUE
*
      RETURN
*
*     End of SPPRFS
*

Here is the call graph for this function:

Here is the caller graph for this function: