claunhr_col_getrfnp()

subroutine claunhr_col_getrfnp	(	integer	m,
		integer	n,
		complex, dimension( lda, * )	a,
		integer	lda,
		complex, dimension( * )	d,
		integer	info
	)

CLAUNHR_COL_GETRFNP

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

Purpose:

 CLAUNHR_COL_GETRFNP computes the modified LU factorization without
 pivoting of a complex general M-by-N matrix A. The factorization has
 the form:

     A - S = L * U,

 where:
    S is a m-by-n diagonal sign matrix with the diagonal D, so that
    D(i) = S(i,i), 1 <= i <= min(M,N). The diagonal D is constructed
    as D(i)=-SIGN(A(i,i)), where A(i,i) is the value after performing
    i-1 steps of Gaussian elimination. This means that the diagonal
    element at each step of "modified" Gaussian elimination is
    at least one in absolute value (so that division-by-zero not
    not possible during the division by the diagonal element);

    L is a M-by-N lower triangular matrix with unit diagonal elements
    (lower trapezoidal if M > N);

    and U is a M-by-N upper triangular matrix
    (upper trapezoidal if M < N).

 This routine is an auxiliary routine used in the Householder
 reconstruction routine CUNHR_COL. In CUNHR_COL, this routine is
 applied to an M-by-N matrix A with orthonormal columns, where each
 element is bounded by one in absolute value. With the choice of
 the matrix S above, one can show that the diagonal element at each
 step of Gaussian elimination is the largest (in absolute value) in
 the column on or below the diagonal, so that no pivoting is required
 for numerical stability [1].

 For more details on the Householder reconstruction algorithm,
 including the modified LU factorization, see [1].

 This is the blocked right-looking version of the algorithm,
 calling Level 3 BLAS to update the submatrix. To factorize a block,
 this routine calls the recursive routine CLAUNHR_COL_GETRFNP2.

 [1] "Reconstructing Householder vectors from tall-skinny QR",
     G. Ballard, J. Demmel, L. Grigori, M. Jacquelin, H.D. Nguyen,
     E. Solomonik, J. Parallel Distrib. Comput.,
     vol. 85, pp. 3-31, 2015.

Parameters

[in]	M	M is INTEGER The number of rows of the matrix A. M >= 0.
[in]	N	N is INTEGER The number of columns of the matrix A. N >= 0.
[in,out]	A	A is COMPLEX array, dimension (LDA,N) On entry, the M-by-N matrix to be factored. On exit, the factors L and U from the factorization A-S=L*U; the unit diagonal elements of L are not stored.
[in]	LDA	LDA is INTEGER The leading dimension of the array A. LDA >= max(1,M).
[out]	D	D is COMPLEX array, dimension min(M,N) The diagonal elements of the diagonal M-by-N sign matrix S, D(i) = S(i,i), where 1 <= i <= min(M,N). The elements can be only ( +1.0, 0.0 ) or (-1.0, 0.0 ).
[out]	INFO	INFO is INTEGER = 0: successful exit < 0: if INFO = -i, the i-th argument had an illegal value

Author

Univ. of Tennessee

Univ. of California Berkeley

Univ. of Colorado Denver

NAG Ltd.

Contributors:

 November 2019, Igor Kozachenko,
                Computer Science Division,
                University of California, Berkeley

Definition at line 145 of file claunhr_col_getrfnp.f.

      IMPLICIT NONE
*
*  -- LAPACK computational 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            INFO, LDA, M, N
*     ..
*     .. Array Arguments ..
      COMPLEX            A( LDA, * ), D( * )
*     ..
*
*  =====================================================================
*
*     .. Parameters ..
      COMPLEX            CONE
      parameter( cone = ( 1.0e+0, 0.0e+0 ) )
*     ..
*     .. Local Scalars ..
      INTEGER            IINFO, J, JB, NB
*     ..
*     .. External Subroutines ..
      EXTERNAL           cgemm, claunhr_col_getrfnp2, ctrsm, xerbla
*     ..
*     .. External Functions ..
      INTEGER            ILAENV
      EXTERNAL           ilaenv
*     ..
*     .. Intrinsic Functions ..
      INTRINSIC          max, min
*     ..
*     .. Executable Statements ..
*
*     Test the input parameters.
*
      info = 0
      IF( m.LT.0 ) THEN
         info = -1
      ELSE IF( n.LT.0 ) THEN
         info = -2
      ELSE IF( lda.LT.max( 1, m ) ) THEN
         info = -4
      END IF
      IF( info.NE.0 ) THEN
         CALL xerbla( 'CLAUNHR_COL_GETRFNP', -info )
         RETURN
      END IF
*
*     Quick return if possible
*
      IF( min( m, n ).EQ.0 )
     $   RETURN
*
*     Determine the block size for this environment.
*
 
      nb = ilaenv( 1, 'CLAUNHR_COL_GETRFNP', ' ', m, n, -1, -1 )
 
      IF( nb.LE.1 .OR. nb.GE.min( m, n ) ) THEN
*
*        Use unblocked code.
*
         CALL claunhr_col_getrfnp2( m, n, a, lda, d, info )
      ELSE
*
*        Use blocked code.
*
         DO j = 1, min( m, n ), nb
            jb = min( min( m, n )-j+1, nb )
*
*           Factor diagonal and subdiagonal blocks.
*
            CALL claunhr_col_getrfnp2( m-j+1, jb, a( j, j ), lda,
     $                                 d( j ), iinfo )
*
            IF( j+jb.LE.n ) THEN
*
*              Compute block row of U.
*
               CALL ctrsm( 'Left', 'Lower', 'No transpose', 'Unit', jb,
     $                     n-j-jb+1, cone, a( j, j ), lda, a( j, j+jb ),
     $                     lda )
               IF( j+jb.LE.m ) THEN
*
*                 Update trailing submatrix.
*
                  CALL cgemm( 'No transpose', 'No transpose', m-j-jb+1,
     $                        n-j-jb+1, jb, -cone, a( j+jb, j ), lda,
     $                        a( j, j+jb ), lda, cone, a( j+jb, j+jb ),
     $                        lda )
               END IF
            END IF
         END DO
      END IF
      RETURN
*
*     End of CLAUNHR_COL_GETRFNP
*

Here is the call graph for this function:

Here is the caller graph for this function: