subroutine spotrf	(	character	UPLO,
		integer	N,
		real, dimension( lda, * )	A,
		integer	LDA,
		integer	INFO
	)

SPOTRF VARIANT: right looking block version of the algorithm, calling Level 3 BLAS.

Purpose:

 SPOTRF computes the Cholesky factorization of a real symmetric
 positive definite matrix A.

 The factorization has the form
    A = U**T * U,  if UPLO = 'U', or
    A = L  * L**T,  if UPLO = 'L',
 where U is an upper triangular matrix and L is lower triangular.

 This is the right looking block version of the algorithm, calling Level 3 BLAS.

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,out]	A	A is REAL array, dimension (LDA,N) On entry, the symmetric 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. On exit, if INFO = 0, the factor U or L from the Cholesky factorization A = U**T*U or A = L*L**T.
[in]	LDA	LDA is INTEGER The leading dimension of the array A. LDA >= max(1,N).
[out]	INFO	INFO is INTEGER = 0: successful exit < 0: if INFO = -i, the i-th argument had an illegal value > 0: if INFO = i, the leading minor of order i is not positive definite, and the factorization could not be completed.

Author

Univ. of Tennessee

Univ. of California Berkeley

Univ. of Colorado Denver

NAG Ltd.

Date

November 2011

Definition at line 102 of file spotrf.f.

*
*  -- LAPACK computational routine (version 3.1) --
*  -- 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, n
*     ..
*     .. Array Arguments ..
      REAL               a( lda, * )
*     ..
*
*  =====================================================================
*
*     .. Parameters ..
      REAL               one
      parameter                ( one = 1.0e+0 )
*     ..
*     .. Local Scalars ..
      LOGICAL            upper
      INTEGER            j, jb, nb
*     ..
*     .. External Functions ..
      LOGICAL            lsame
      INTEGER            ilaenv
      EXTERNAL           lsame, ilaenv
*     ..
*     .. External Subroutines ..
      EXTERNAL           sgemm, spotf2, ssyrk, strsm, xerbla
*     ..
*     .. Intrinsic Functions ..
      INTRINSIC          max, min
*     ..
*     .. 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( lda.LT.max( 1, n ) ) THEN
         info = -4
      END IF
      IF( info.NE.0 ) THEN
         CALL xerbla( 'SPOTRF', -info )
         RETURN
      END IF
*
*     Quick return if possible
*
      IF( n.EQ.0 )
     $   RETURN
*
*     Determine the block size for this environment.
*
      nb = ilaenv( 1, 'SPOTRF', uplo, n, -1, -1, -1 )
      IF( nb.LE.1 .OR. nb.GE.n ) THEN
*
*        Use unblocked code.
*
         CALL spotf2( uplo, n, a, lda, info )
      ELSE
*
*        Use blocked code.
*
         IF( upper ) THEN
*
*           Compute the Cholesky factorization A = U'*U.
*
            DO 10 j = 1, n, nb
*
*              Update and factorize the current diagonal block and test
*              for non-positive-definiteness.
*
               jb = min( nb, n-j+1 )

               CALL spotf2( 'Upper', jb, a( j, j ), lda, info )

               IF( info.NE.0 )
     $            GO TO 30

               IF( j+jb.LE.n ) THEN
*
*                 Updating the trailing submatrix.
*
                  CALL strsm( 'Left', 'Upper', 'Transpose', 'Non-unit',
     $                        jb, n-j-jb+1, one, a( j, j ), lda,
     $                        a( j, j+jb ), lda )
                  CALL ssyrk( 'Upper', 'Transpose', n-j-jb+1, jb, -one,
     $                        a( j, j+jb ), lda, 
     $                        one, a( j+jb, j+jb ), lda )
               END IF
   10       CONTINUE
*
         ELSE
*
*           Compute the Cholesky factorization A = L*L'.
*
            DO 20 j = 1, n, nb
*
*              Update and factorize the current diagonal block and test
*              for non-positive-definiteness.
*
               jb = min( nb, n-j+1 )

               CALL spotf2( 'Lower', jb, a( j, j ), lda, info )

               IF( info.NE.0 )
     $            GO TO 30

               IF( j+jb.LE.n ) THEN
*
*                Updating the trailing submatrix.
*
                 CALL strsm( 'Right', 'Lower', 'Transpose', 'Non-unit',
     $                       n-j-jb+1, jb, one, a( j, j ), lda,
     $                       a( j+jb, j ), lda )

                 CALL ssyrk( 'Lower', 'No Transpose', n-j-jb+1, jb, 
     $                       -one, a( j+jb, j ), lda, 
     $                       one, a( j+jb, j+jb ), lda )
               END IF
   20       CONTINUE
         END IF
      END IF
      GO TO 40
*
   30 CONTINUE
      info = info + j - 1
*
   40 CONTINUE
      RETURN
*
*     End of SPOTRF
*

Here is the call graph for this function: