d0/dcd/cgebrd_8f_source.html

 *> \brief \b CGEBRD
 *
 *  =========== DOCUMENTATION ===========
 *
 * Online html documentation available at
 *            http://www.netlib.org/lapack/explore-html/
 *
 *> \htmlonly
 *> Download CGEBRD + dependencies
 *> <a href="http://www.netlib.org/cgi-bin/netlibfiles.tgz?format=tgz&filename=/lapack/lapack_routine/cgebrd.f">
 *> [TGZ]</a>
 *> <a href="http://www.netlib.org/cgi-bin/netlibfiles.zip?format=zip&filename=/lapack/lapack_routine/cgebrd.f">
 *> [ZIP]</a>
 *> <a href="http://www.netlib.org/cgi-bin/netlibfiles.txt?format=txt&filename=/lapack/lapack_routine/cgebrd.f">
 *> [TXT]</a>
 *> \endhtmlonly
 *
 *  Definition:
 *  ===========
 *
 *       SUBROUTINE CGEBRD( M, N, A, LDA, D, E, TAUQ, TAUP, WORK, LWORK,
 *                          INFO )
 *
 *       .. Scalar Arguments ..
 *       INTEGER            INFO, LDA, LWORK, M, N
 *       ..
 *       .. Array Arguments ..
 *       REAL               D( * ), E( * )
 *       COMPLEX            A( LDA, * ), TAUP( * ), TAUQ( * ),
 *      $                   WORK( * )
 *       ..
 *
 *
 *> \par Purpose:
 *  =============
 *>
 *> \verbatim
 *>
 *> CGEBRD reduces a general complex M-by-N matrix A to upper or lower
 *> bidiagonal form B by a unitary transformation: Q**H * A * P = B.
 *>
 *> If m >= n, B is upper bidiagonal; if m < n, B is lower bidiagonal.
 *> \endverbatim
 *
 *  Arguments:
 *  ==========
 *
 *> \param[in] M
 *> \verbatim
 *>          M is INTEGER
 *>          The number of rows in the matrix A.  M >= 0.
 *> \endverbatim
 *>
 *> \param[in] N
 *> \verbatim
 *>          N is INTEGER
 *>          The number of columns in the matrix A.  N >= 0.
 *> \endverbatim
 *>
 *> \param[in,out] A
 *> \verbatim
 *>          A is COMPLEX array, dimension (LDA,N)
 *>          On entry, the M-by-N general matrix to be reduced.
 *>          On exit,
 *>          if m >= n, the diagonal and the first superdiagonal are
 *>            overwritten with the upper bidiagonal matrix B; the
 *>            elements below the diagonal, with the array TAUQ, represent
 *>            the unitary matrix Q as a product of elementary
 *>            reflectors, and the elements above the first superdiagonal,
 *>            with the array TAUP, represent the unitary matrix P as
 *>            a product of elementary reflectors;
 *>          if m < n, the diagonal and the first subdiagonal are
 *>            overwritten with the lower bidiagonal matrix B; the
 *>            elements below the first subdiagonal, with the array TAUQ,
 *>            represent the unitary matrix Q as a product of
 *>            elementary reflectors, and the elements above the diagonal,
 *>            with the array TAUP, represent the unitary matrix P as
 *>            a product of elementary reflectors.
 *>          See Further Details.
 *> \endverbatim
 *>
 *> \param[in] LDA
 *> \verbatim
 *>          LDA is INTEGER
 *>          The leading dimension of the array A.  LDA >= max(1,M).
 *> \endverbatim
 *>
 *> \param[out] D
 *> \verbatim
 *>          D is REAL array, dimension (min(M,N))
 *>          The diagonal elements of the bidiagonal matrix B:
 *>          D(i) = A(i,i).
 *> \endverbatim
 *>
 *> \param[out] E
 *> \verbatim
 *>          E is REAL array, dimension (min(M,N)-1)
 *>          The off-diagonal elements of the bidiagonal matrix B:
 *>          if m >= n, E(i) = A(i,i+1) for i = 1,2,...,n-1;
 *>          if m < n, E(i) = A(i+1,i) for i = 1,2,...,m-1.
 *> \endverbatim
 *>
 *> \param[out] TAUQ
 *> \verbatim
 *>          TAUQ is COMPLEX array, dimension (min(M,N))
 *>          The scalar factors of the elementary reflectors which
 *>          represent the unitary matrix Q. See Further Details.
 *> \endverbatim
 *>
 *> \param[out] TAUP
 *> \verbatim
 *>          TAUP is COMPLEX array, dimension (min(M,N))
 *>          The scalar factors of the elementary reflectors which
 *>          represent the unitary matrix P. See Further Details.
 *> \endverbatim
 *>
 *> \param[out] WORK
 *> \verbatim
 *>          WORK is COMPLEX array, dimension (MAX(1,LWORK))
 *>          On exit, if INFO = 0, WORK(1) returns the optimal LWORK.
 *> \endverbatim
 *>
 *> \param[in] LWORK
 *> \verbatim
 *>          LWORK is INTEGER
 *>          The length of the array WORK.  LWORK >= max(1,M,N).
 *>          For optimum performance LWORK >= (M+N)*NB, where NB
 *>          is the optimal blocksize.
 *>
 *>          If LWORK = -1, then a workspace query is assumed; the routine
 *>          only calculates the optimal size of the WORK array, returns
 *>          this value as the first entry of the WORK array, and no error
 *>          message related to LWORK is issued by XERBLA.
 *> \endverbatim
 *>
 *> \param[out] INFO
 *> \verbatim
 *>          INFO is INTEGER
 *>          = 0:  successful exit.
 *>          < 0:  if INFO = -i, the i-th argument had an illegal value.
 *> \endverbatim
 *
 *  Authors:
 *  ========
 *
 *> \author Univ. of Tennessee
 *> \author Univ. of California Berkeley
 *> \author Univ. of Colorado Denver
 *> \author NAG Ltd.
 *
 *> \ingroup gebrd
 *
 *> \par Further Details:
 *  =====================
 *>
 *> \verbatim
 *>
 *>  The matrices Q and P are represented as products of elementary
 *>  reflectors:
 *>
 *>  If m >= n,
 *>
 *>     Q = H(1) H(2) . . . H(n)  and  P = G(1) G(2) . . . G(n-1)
 *>
 *>  Each H(i) and G(i) has the form:
 *>
 *>     H(i) = I - tauq * v * v**H  and G(i) = I - taup * u * u**H
 *>
 *>  where tauq and taup are complex scalars, and v and u are complex
 *>  vectors; v(1:i-1) = 0, v(i) = 1, and v(i+1:m) is stored on exit in
 *>  A(i+1:m,i); u(1:i) = 0, u(i+1) = 1, and u(i+2:n) is stored on exit in
 *>  A(i,i+2:n); tauq is stored in TAUQ(i) and taup in TAUP(i).
 *>
 *>  If m < n,
 *>
 *>     Q = H(1) H(2) . . . H(m-1)  and  P = G(1) G(2) . . . G(m)
 *>
 *>  Each H(i) and G(i) has the form:
 *>
 *>     H(i) = I - tauq * v * v**H  and G(i) = I - taup * u * u**H
 *>
 *>  where tauq and taup are complex scalars, and v and u are complex
 *>  vectors; v(1:i) = 0, v(i+1) = 1, and v(i+2:m) is stored on exit in
 *>  A(i+2:m,i); u(1:i-1) = 0, u(i) = 1, and u(i+1:n) is stored on exit in
 *>  A(i,i+1:n); tauq is stored in TAUQ(i) and taup in TAUP(i).
 *>
 *>  The contents of A on exit are illustrated by the following examples:
 *>
 *>  m = 6 and n = 5 (m > n):          m = 5 and n = 6 (m < n):
 *>
 *>    (  d   e   u1  u1  u1 )           (  d   u1  u1  u1  u1  u1 )
 *>    (  v1  d   e   u2  u2 )           (  e   d   u2  u2  u2  u2 )
 *>    (  v1  v2  d   e   u3 )           (  v1  e   d   u3  u3  u3 )
 *>    (  v1  v2  v3  d   e  )           (  v1  v2  e   d   u4  u4 )
 *>    (  v1  v2  v3  v4  d  )           (  v1  v2  v3  e   d   u5 )
 *>    (  v1  v2  v3  v4  v5 )
 *>
 *>  where d and e denote diagonal and off-diagonal elements of B, vi
 *>  denotes an element of the vector defining H(i), and ui an element of
 *>  the vector defining G(i).
 *> \endverbatim
 *>
 *  =====================================================================
       SUBROUTINE cgebrd( M, N, A, LDA, D, E, TAUQ, TAUP, WORK, LWORK,
      $                   INFO )
 *
 *  -- 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, LWORK, M, N
 *     ..
 *     .. Array Arguments ..
       REAL               D( * ), E( * )
       COMPLEX            A( lda, * ), TAUP( * ), TAUQ( * ),
      $                   work( * )
 *     ..
 *
 *  =====================================================================
 *
 *     .. Parameters ..
       COMPLEX            ONE
       parameter( one = ( 1.0e+0, 0.0e+0 ) )
 *     ..
 *     .. Local Scalars ..
       LOGICAL            LQUERY
       INTEGER            I, IINFO, J, LDWRKX, LDWRKY, LWKOPT, MINMN, NB,
      $                   nbmin, nx, ws
 *     ..
 *     .. External Subroutines ..
       EXTERNAL           cgebd2, cgemm, clabrd, xerbla
 *     ..
 *     .. Intrinsic Functions ..
       INTRINSIC          max, min, real
 *     ..
 *     .. External Functions ..
       INTEGER            ILAENV
       EXTERNAL           ilaenv
 *     ..
 *     .. Executable Statements ..
 *
 *     Test the input parameters
 *
       info = 0
       nb = max( 1, ilaenv( 1, 'CGEBRD', ' ', m, n, -1, -1 ) )
       lwkopt = ( m+n )*nb
       work( 1 ) = REAL( lwkopt )
       lquery = ( lwork.EQ.-1 )
       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
       ELSE IF( lwork.LT.max( 1, m, n ) .AND. .NOT.lquery ) THEN
          info = -10
       END IF
       IF( info.LT.0 ) THEN
          CALL xerbla( 'CGEBRD', -info )
          RETURN
       ELSE IF( lquery ) THEN
          RETURN
       END IF
 *
 *     Quick return if possible
 *
       minmn = min( m, n )
       IF( minmn.EQ.0 ) THEN
          work( 1 ) = 1
          RETURN
       END IF
 *
       ws = max( m, n )
       ldwrkx = m
       ldwrky = n
 *
       IF( nb.GT.1 .AND. nb.LT.minmn ) THEN
 *
 *        Set the crossover point NX.
 *
          nx = max( nb, ilaenv( 3, 'CGEBRD', ' ', m, n, -1, -1 ) )
 *
 *        Determine when to switch from blocked to unblocked code.
 *
          IF( nx.LT.minmn ) THEN
             ws = ( m+n )*nb
             IF( lwork.LT.ws ) THEN
 *
 *              Not enough work space for the optimal NB, consider using
 *              a smaller block size.
 *
                nbmin = ilaenv( 2, 'CGEBRD', ' ', m, n, -1, -1 )
                IF( lwork.GE.( m+n )*nbmin ) THEN
                   nb = lwork / ( m+n )
                ELSE
                   nb = 1
                   nx = minmn
                END IF
             END IF
          END IF
       ELSE
          nx = minmn
       END IF
 *
       DO 30 i = 1, minmn - nx, nb
 *
 *        Reduce rows and columns i:i+ib-1 to bidiagonal form and return
 *        the matrices X and Y which are needed to update the unreduced
 *        part of the matrix
 *
          CALL clabrd( m-i+1, n-i+1, nb, a( i, i ), lda, d( i ), e( i ),
      $                tauq( i ), taup( i ), work, ldwrkx,
      $                work( ldwrkx*nb+1 ), ldwrky )
 *
 *        Update the trailing submatrix A(i+ib:m,i+ib:n), using
 *        an update of the form  A := A - V*Y**H - X*U**H
 *
          CALL cgemm( 'No transpose', 'Conjugate transpose', m-i-nb+1,
      $               n-i-nb+1, nb, -one, a( i+nb, i ), lda,
      $               work( ldwrkx*nb+nb+1 ), ldwrky, one,
      $               a( i+nb, i+nb ), lda )
          CALL cgemm( 'No transpose', 'No transpose', m-i-nb+1, n-i-nb+1,
      $               nb, -one, work( nb+1 ), ldwrkx, a( i, i+nb ), lda,
      $               one, a( i+nb, i+nb ), lda )
 *
 *        Copy diagonal and off-diagonal elements of B back into A
 *
          IF( m.GE.n ) THEN
             DO 10 j = i, i + nb - 1
                a( j, j ) = d( j )
                a( j, j+1 ) = e( j )
    10       CONTINUE
          ELSE
             DO 20 j = i, i + nb - 1
                a( j, j ) = d( j )
                a( j+1, j ) = e( j )
    20       CONTINUE
          END IF
    30 CONTINUE
 *
 *     Use unblocked code to reduce the remainder of the matrix
 *
       CALL cgebd2( m-i+1, n-i+1, a( i, i ), lda, d( i ), e( i ),
      $             tauq( i ), taup( i ), work, iinfo )
       work( 1 ) = ws
       RETURN
 *
 *     End of CGEBRD
 *
       END
clabrd
subroutine clabrd(M, N, NB, A, LDA, D, E, TAUQ, TAUP, X, LDX, Y, LDY)
CLABRD reduces the first nb rows and columns of a general matrix to a bidiagonal form.
Definition: clabrd.f:212

xerbla
subroutine xerbla(SRNAME, INFO)
XERBLA
Definition: xerbla.f:60

cgebd2
subroutine cgebd2(M, N, A, LDA, D, E, TAUQ, TAUP, WORK, INFO)
CGEBD2 reduces a general matrix to bidiagonal form using an unblocked algorithm.
Definition: cgebd2.f:190

cgemm
subroutine cgemm(TRANSA, TRANSB, M, N, K, ALPHA, A, LDA, B, LDB, BETA, C, LDC)
CGEMM
Definition: cgemm.f:187

cgebrd
subroutine cgebrd(M, N, A, LDA, D, E, TAUQ, TAUP, WORK, LWORK, INFO)
CGEBRD
Definition: cgebrd.f:206