LAPACK  3.10.0
LAPACK: Linear Algebra PACKage

◆ cgebrd()

subroutine cgebrd ( integer  M,
integer  N,
complex, dimension( lda, * )  A,
integer  LDA,
real, dimension( * )  D,
real, dimension( * )  E,
complex, dimension( * )  TAUQ,
complex, dimension( * )  TAUP,
complex, dimension( * )  WORK,
integer  LWORK,
integer  INFO 
)

CGEBRD

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

Purpose:
 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.
Parameters
[in]M
          M is INTEGER
          The number of rows in the matrix A.  M >= 0.
[in]N
          N is INTEGER
          The number of columns in the matrix A.  N >= 0.
[in,out]A
          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.
[in]LDA
          LDA is INTEGER
          The leading dimension of the array A.  LDA >= max(1,M).
[out]D
          D is REAL array, dimension (min(M,N))
          The diagonal elements of the bidiagonal matrix B:
          D(i) = A(i,i).
[out]E
          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.
[out]TAUQ
          TAUQ is COMPLEX array, dimension (min(M,N))
          The scalar factors of the elementary reflectors which
          represent the unitary matrix Q. See Further Details.
[out]TAUP
          TAUP is COMPLEX array, dimension (min(M,N))
          The scalar factors of the elementary reflectors which
          represent the unitary matrix P. See Further Details.
[out]WORK
          WORK is COMPLEX array, dimension (MAX(1,LWORK))
          On exit, if INFO = 0, WORK(1) returns the optimal LWORK.
[in]LWORK
          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.
[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.
Further Details:
  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).

Definition at line 204 of file cgebrd.f.

206 *
207 * -- LAPACK computational routine --
208 * -- LAPACK is a software package provided by Univ. of Tennessee, --
209 * -- Univ. of California Berkeley, Univ. of Colorado Denver and NAG Ltd..--
210 *
211 * .. Scalar Arguments ..
212  INTEGER INFO, LDA, LWORK, M, N
213 * ..
214 * .. Array Arguments ..
215  REAL D( * ), E( * )
216  COMPLEX A( LDA, * ), TAUP( * ), TAUQ( * ),
217  $ WORK( * )
218 * ..
219 *
220 * =====================================================================
221 *
222 * .. Parameters ..
223  COMPLEX ONE
224  parameter( one = ( 1.0e+0, 0.0e+0 ) )
225 * ..
226 * .. Local Scalars ..
227  LOGICAL LQUERY
228  INTEGER I, IINFO, J, LDWRKX, LDWRKY, LWKOPT, MINMN, NB,
229  $ NBMIN, NX, WS
230 * ..
231 * .. External Subroutines ..
232  EXTERNAL cgebd2, cgemm, clabrd, xerbla
233 * ..
234 * .. Intrinsic Functions ..
235  INTRINSIC max, min, real
236 * ..
237 * .. External Functions ..
238  INTEGER ILAENV
239  EXTERNAL ilaenv
240 * ..
241 * .. Executable Statements ..
242 *
243 * Test the input parameters
244 *
245  info = 0
246  nb = max( 1, ilaenv( 1, 'CGEBRD', ' ', m, n, -1, -1 ) )
247  lwkopt = ( m+n )*nb
248  work( 1 ) = real( lwkopt )
249  lquery = ( lwork.EQ.-1 )
250  IF( m.LT.0 ) THEN
251  info = -1
252  ELSE IF( n.LT.0 ) THEN
253  info = -2
254  ELSE IF( lda.LT.max( 1, m ) ) THEN
255  info = -4
256  ELSE IF( lwork.LT.max( 1, m, n ) .AND. .NOT.lquery ) THEN
257  info = -10
258  END IF
259  IF( info.LT.0 ) THEN
260  CALL xerbla( 'CGEBRD', -info )
261  RETURN
262  ELSE IF( lquery ) THEN
263  RETURN
264  END IF
265 *
266 * Quick return if possible
267 *
268  minmn = min( m, n )
269  IF( minmn.EQ.0 ) THEN
270  work( 1 ) = 1
271  RETURN
272  END IF
273 *
274  ws = max( m, n )
275  ldwrkx = m
276  ldwrky = n
277 *
278  IF( nb.GT.1 .AND. nb.LT.minmn ) THEN
279 *
280 * Set the crossover point NX.
281 *
282  nx = max( nb, ilaenv( 3, 'CGEBRD', ' ', m, n, -1, -1 ) )
283 *
284 * Determine when to switch from blocked to unblocked code.
285 *
286  IF( nx.LT.minmn ) THEN
287  ws = ( m+n )*nb
288  IF( lwork.LT.ws ) THEN
289 *
290 * Not enough work space for the optimal NB, consider using
291 * a smaller block size.
292 *
293  nbmin = ilaenv( 2, 'CGEBRD', ' ', m, n, -1, -1 )
294  IF( lwork.GE.( m+n )*nbmin ) THEN
295  nb = lwork / ( m+n )
296  ELSE
297  nb = 1
298  nx = minmn
299  END IF
300  END IF
301  END IF
302  ELSE
303  nx = minmn
304  END IF
305 *
306  DO 30 i = 1, minmn - nx, nb
307 *
308 * Reduce rows and columns i:i+ib-1 to bidiagonal form and return
309 * the matrices X and Y which are needed to update the unreduced
310 * part of the matrix
311 *
312  CALL clabrd( m-i+1, n-i+1, nb, a( i, i ), lda, d( i ), e( i ),
313  $ tauq( i ), taup( i ), work, ldwrkx,
314  $ work( ldwrkx*nb+1 ), ldwrky )
315 *
316 * Update the trailing submatrix A(i+ib:m,i+ib:n), using
317 * an update of the form A := A - V*Y**H - X*U**H
318 *
319  CALL cgemm( 'No transpose', 'Conjugate transpose', m-i-nb+1,
320  $ n-i-nb+1, nb, -one, a( i+nb, i ), lda,
321  $ work( ldwrkx*nb+nb+1 ), ldwrky, one,
322  $ a( i+nb, i+nb ), lda )
323  CALL cgemm( 'No transpose', 'No transpose', m-i-nb+1, n-i-nb+1,
324  $ nb, -one, work( nb+1 ), ldwrkx, a( i, i+nb ), lda,
325  $ one, a( i+nb, i+nb ), lda )
326 *
327 * Copy diagonal and off-diagonal elements of B back into A
328 *
329  IF( m.GE.n ) THEN
330  DO 10 j = i, i + nb - 1
331  a( j, j ) = d( j )
332  a( j, j+1 ) = e( j )
333  10 CONTINUE
334  ELSE
335  DO 20 j = i, i + nb - 1
336  a( j, j ) = d( j )
337  a( j+1, j ) = e( j )
338  20 CONTINUE
339  END IF
340  30 CONTINUE
341 *
342 * Use unblocked code to reduce the remainder of the matrix
343 *
344  CALL cgebd2( m-i+1, n-i+1, a( i, i ), lda, d( i ), e( i ),
345  $ tauq( i ), taup( i ), work, iinfo )
346  work( 1 ) = ws
347  RETURN
348 *
349 * End of CGEBRD
350 *
integer function ilaenv(ISPEC, NAME, OPTS, N1, N2, N3, N4)
ILAENV
Definition: ilaenv.f:162
subroutine xerbla(SRNAME, INFO)
XERBLA
Definition: xerbla.f:60
subroutine cgemm(TRANSA, TRANSB, M, N, K, ALPHA, A, LDA, B, LDB, BETA, C, LDC)
CGEMM
Definition: cgemm.f:187
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
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
Here is the call graph for this function:
Here is the caller graph for this function: