dc/d3a/clarzb_8f_source.html

*> \brief \b CLARZB applies a block reflector or its conjugate-transpose to a general matrix.

*

*  =========== DOCUMENTATION ===========

*

* Online html documentation available at

*            http://www.netlib.org/lapack/explore-html/

*

*> Download CLARZB + dependencies

*> <a href="http://www.netlib.org/cgi-bin/netlibfiles.tgz?format=tgz&filename=/lapack/lapack_routine/clarzb.f">

*> [TGZ]</a>

*> <a href="http://www.netlib.org/cgi-bin/netlibfiles.zip?format=zip&filename=/lapack/lapack_routine/clarzb.f">

*> [ZIP]</a>

*> <a href="http://www.netlib.org/cgi-bin/netlibfiles.txt?format=txt&filename=/lapack/lapack_routine/clarzb.f">

*> [TXT]</a>

*

*  Definition:

*  ===========

*

*       SUBROUTINE CLARZB( SIDE, TRANS, DIRECT, STOREV, M, N, K, L, V,

*                          LDV, T, LDT, C, LDC, WORK, LDWORK )

*

*       .. Scalar Arguments ..

*       CHARACTER          DIRECT, SIDE, STOREV, TRANS

*       INTEGER            K, L, LDC, LDT, LDV, LDWORK, M, N

*       ..

*       .. Array Arguments ..

*       COMPLEX            C( LDC, * ), T( LDT, * ), V( LDV, * ),

*      $                   WORK( LDWORK, * )

*       ..

*

*

*> \par Purpose:

*  =============

*>

*> \verbatim

*>

*> CLARZB applies a complex block reflector H or its transpose H**H

*> to a complex distributed M-by-N  C from the left or the right.

*>

*> Currently, only STOREV = 'R' and DIRECT = 'B' are supported.

*> \endverbatim

*

*  Arguments:

*  ==========

*

*> \param[in] SIDE

*> \verbatim

*>          SIDE is CHARACTER*1

*>          = 'L': apply H or H**H from the Left

*>          = 'R': apply H or H**H from the Right

*> \endverbatim

*>

*> \param[in] TRANS

*> \verbatim

*>          TRANS is CHARACTER*1

*>          = 'N': apply H (No transpose)

*>          = 'C': apply H**H (Conjugate transpose)

*> \endverbatim

*>

*> \param[in] DIRECT

*> \verbatim

*>          DIRECT is CHARACTER*1

*>          Indicates how H is formed from a product of elementary

*>          reflectors

*>          = 'F': H = H(1) H(2) . . . H(k) (Forward, not supported yet)

*>          = 'B': H = H(k) . . . H(2) H(1) (Backward)

*> \endverbatim

*>

*> \param[in] STOREV

*> \verbatim

*>          STOREV is CHARACTER*1

*>          Indicates how the vectors which define the elementary

*>          reflectors are stored:

*>          = 'C': Columnwise                        (not supported yet)

*>          = 'R': Rowwise

*> \endverbatim

*>

*> \param[in] M

*> \verbatim

*>          M is INTEGER

*>          The number of rows of the matrix C.

*> \endverbatim

*>

*> \param[in] N

*> \verbatim

*>          N is INTEGER

*>          The number of columns of the matrix C.

*> \endverbatim

*>

*> \param[in] K

*> \verbatim

*>          K is INTEGER

*>          The order of the matrix T (= the number of elementary

*>          reflectors whose product defines the block reflector).

*> \endverbatim

*>

*> \param[in] L

*> \verbatim

*>          L is INTEGER

*>          The number of columns of the matrix V containing the

*>          meaningful part of the Householder reflectors.

*>          If SIDE = 'L', M >= L >= 0, if SIDE = 'R', N >= L >= 0.

*> \endverbatim

*>

*> \param[in] V

*> \verbatim

*>          V is COMPLEX array, dimension (LDV,NV).

*>          If STOREV = 'C', NV = K; if STOREV = 'R', NV = L.

*> \endverbatim

*>

*> \param[in] LDV

*> \verbatim

*>          LDV is INTEGER

*>          The leading dimension of the array V.

*>          If STOREV = 'C', LDV >= L; if STOREV = 'R', LDV >= K.

*> \endverbatim

*>

*> \param[in] T

*> \verbatim

*>          T is COMPLEX array, dimension (LDT,K)

*>          The triangular K-by-K matrix T in the representation of the

*>          block reflector.

*> \endverbatim

*>

*> \param[in] LDT

*> \verbatim

*>          LDT is INTEGER

*>          The leading dimension of the array T. LDT >= K.

*> \endverbatim

*>

*> \param[in,out] C

*> \verbatim

*>          C is COMPLEX array, dimension (LDC,N)

*>          On entry, the M-by-N matrix C.

*>          On exit, C is overwritten by H*C or H**H*C or C*H or C*H**H.

*> \endverbatim

*>

*> \param[in] LDC

*> \verbatim

*>          LDC is INTEGER

*>          The leading dimension of the array C. LDC >= max(1,M).

*> \endverbatim

*>

*> \param[out] WORK

*> \verbatim

*>          WORK is COMPLEX array, dimension (LDWORK,K)

*> \endverbatim

*>

*> \param[in] LDWORK

*> \verbatim

*>          LDWORK is INTEGER

*>          The leading dimension of the array WORK.

*>          If SIDE = 'L', LDWORK >= max(1,N);

*>          if SIDE = 'R', LDWORK >= max(1,M).

*> \endverbatim

*

*  Authors:

*  ========

*

*> \author Univ. of Tennessee

*> \author Univ. of California Berkeley

*> \author Univ. of Colorado Denver

*> \author NAG Ltd.

*

*> \ingroup larzb

*

*> \par Contributors:

*  ==================

*>

*>    A. Petitet, Computer Science Dept., Univ. of Tenn., Knoxville, USA

*

*> \par Further Details:

*  =====================

*>

*> \verbatim

*> \endverbatim

*>

*  =====================================================================


      SUBROUTINE clarzb( SIDE, TRANS, DIRECT, STOREV, M, N, K, L, V,

     $                   LDV, T, LDT, C, LDC, WORK, LDWORK )

*

*  -- 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 ..

      CHARACTER          DIRECT, SIDE, STOREV, TRANS

      INTEGER            K, L, LDC, LDT, LDV, LDWORK, M, N

*     ..

*     .. Array Arguments ..

      COMPLEX            C( LDC, * ), T( LDT, * ), V( LDV, * ),

     $                   work( ldwork, * )

*     ..

*

*  =====================================================================

*

*     .. Parameters ..

      COMPLEX            ONE

      parameter( one = ( 1.0e+0, 0.0e+0 ) )

*     ..

*     .. Local Scalars ..

      CHARACTER          TRANST

      INTEGER            I, INFO, J

*     ..

*     .. External Functions ..

      LOGICAL            LSAME

      EXTERNAL           lsame

*     ..

*     .. External Subroutines ..

      EXTERNAL           ccopy, cgemm, clacgv, ctrmm, xerbla

*     ..

*     .. Executable Statements ..

*

*     Quick return if possible

*

      IF( m.LE.0 .OR. n.LE.0 )

     $   RETURN

*

*     Check for currently supported options

*

      info = 0

      IF( .NOT.lsame( direct, 'B' ) ) THEN

         info = -3

      ELSE IF( .NOT.lsame( storev, 'R' ) ) THEN

         info = -4

      END IF

      IF( info.NE.0 ) THEN

         CALL xerbla( 'CLARZB', -info )

         RETURN

      END IF

*

      IF( lsame( trans, 'N' ) ) THEN

         transt = 'C'

      ELSE

         transt = 'N'

      END IF

*

      IF( lsame( side, 'L' ) ) THEN

*

*        Form  H * C  or  H**H * C

*

*        W( 1:n, 1:k ) = C( 1:k, 1:n )**H

*

         DO 10 j = 1, k

            CALL ccopy( n, c( j, 1 ), ldc, work( 1, j ), 1 )

   10    CONTINUE

*

*        W( 1:n, 1:k ) = W( 1:n, 1:k ) + ...

*                        C( m-l+1:m, 1:n )**H * V( 1:k, 1:l )**T

*

         IF( l.GT.0 )

     $      CALL cgemm( 'Transpose', 'Conjugate transpose', n, k, l,

     $                  one, c( m-l+1, 1 ), ldc, v, ldv, one, work,

     $                  ldwork )

*

*        W( 1:n, 1:k ) = W( 1:n, 1:k ) * T**T  or  W( 1:m, 1:k ) * T

*

         CALL ctrmm( 'Right', 'Lower', transt, 'Non-unit', n, k, one,

     $               t,

     $               ldt, work, ldwork )

*

*        C( 1:k, 1:n ) = C( 1:k, 1:n ) - W( 1:n, 1:k )**H

*

         DO 30 j = 1, n

            DO 20 i = 1, k

               c( i, j ) = c( i, j ) - work( j, i )

   20       CONTINUE

   30    CONTINUE

*

*        C( m-l+1:m, 1:n ) = C( m-l+1:m, 1:n ) - ...

*                            V( 1:k, 1:l )**H * W( 1:n, 1:k )**H

*

         IF( l.GT.0 )

     $      CALL cgemm( 'Transpose', 'Transpose', l, n, k, -one, v,

     $                  ldv,

     $                  work, ldwork, one, c( m-l+1, 1 ), ldc )

*

      ELSE IF( lsame( side, 'R' ) ) THEN

*

*        Form  C * H  or  C * H**H

*

*        W( 1:m, 1:k ) = C( 1:m, 1:k )

*

         DO 40 j = 1, k

            CALL ccopy( m, c( 1, j ), 1, work( 1, j ), 1 )

   40    CONTINUE

*

*        W( 1:m, 1:k ) = W( 1:m, 1:k ) + ...

*                        C( 1:m, n-l+1:n ) * V( 1:k, 1:l )**H

*

         IF( l.GT.0 )

     $      CALL cgemm( 'No transpose', 'Transpose', m, k, l, one,

     $                  c( 1, n-l+1 ), ldc, v, ldv, one, work, ldwork )

*

*        W( 1:m, 1:k ) = W( 1:m, 1:k ) * conjg( T )  or

*                        W( 1:m, 1:k ) * T**H

*

         DO 50 j = 1, k

            CALL clacgv( k-j+1, t( j, j ), 1 )

   50    CONTINUE

         CALL ctrmm( 'Right', 'Lower', trans, 'Non-unit', m, k, one,

     $               t,

     $               ldt, work, ldwork )

         DO 60 j = 1, k

            CALL clacgv( k-j+1, t( j, j ), 1 )

   60    CONTINUE

*

*        C( 1:m, 1:k ) = C( 1:m, 1:k ) - W( 1:m, 1:k )

*

         DO 80 j = 1, k

            DO 70 i = 1, m

               c( i, j ) = c( i, j ) - work( i, j )

   70       CONTINUE

   80    CONTINUE

*

*        C( 1:m, n-l+1:n ) = C( 1:m, n-l+1:n ) - ...

*                            W( 1:m, 1:k ) * conjg( V( 1:k, 1:l ) )

*

         DO 90 j = 1, l

            CALL clacgv( k, v( 1, j ), 1 )

   90    CONTINUE

         IF( l.GT.0 )

     $      CALL cgemm( 'No transpose', 'No transpose', m, l, k,

     $                  -one,

     $                  work, ldwork, v, ldv, one, c( 1, n-l+1 ), ldc )

         DO 100 j = 1, l

            CALL clacgv( k, v( 1, j ), 1 )

  100    CONTINUE

*

      END IF

*

      RETURN

*

*     End of CLARZB

*


      END

xerbla
subroutine xerbla(srname, info)
Definition cblat2.f:3285

ccopy
subroutine ccopy(n, cx, incx, cy, incy)
CCOPY
Definition ccopy.f:81

cgemm
subroutine cgemm(transa, transb, m, n, k, alpha, a, lda, b, ldb, beta, c, ldc)
CGEMM
Definition cgemm.f:188

clacgv
subroutine clacgv(n, x, incx)
CLACGV conjugates a complex vector.
Definition clacgv.f:72

clarzb
subroutine clarzb(side, trans, direct, storev, m, n, k, l, v, ldv, t, ldt, c, ldc, work, ldwork)
CLARZB applies a block reflector or its conjugate-transpose to a general matrix.
Definition clarzb.f:181

ctrmm
subroutine ctrmm(side, uplo, transa, diag, m, n, alpha, a, lda, b, ldb)
CTRMM
Definition ctrmm.f:177