/* Subroutine */ int cgebrd_(integer *m, integer *n, complex *a, integer *lda,
real *d, real *e, complex *tauq, complex *taup, complex *work,
integer *lwork, integer *info)
{
/* -- LAPACK routine (version 2.0) --
Univ. of Tennessee, Univ. of California Berkeley, NAG Ltd.,
Courant Institute, Argonne National Lab, and Rice University
September 30, 1994
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.
Arguments
=========
M (input) INTEGER
The number of rows in the matrix A. M >= 0.
N (input) INTEGER
The number of columns in the matrix A. N >= 0.
A (input/output) 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.
LDA (input) INTEGER
The leading dimension of the array A. LDA >= max(1,M).
D (output) REAL array, dimension (min(M,N))
The diagonal elements of the bidiagonal matrix B:
D(i) = A(i,i).
E (output) 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.
TAUQ (output) COMPLEX array dimension (min(M,N))
The scalar factors of the elementary reflectors which
represent the unitary matrix Q. See Further Details.
TAUP (output) COMPLEX array, dimension (min(M,N))
The scalar factors of the elementary reflectors which
represent the unitary matrix P. See Further Details.
WORK (workspace/output) COMPLEX array, dimension (LWORK)
On exit, if INFO = 0, WORK(1) returns the optimal LWORK.
LWORK (input) 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.
INFO (output) INTEGER
= 0: successful exit.
< 0: if INFO = -i, the i-th argument had an illegal value.
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' and G(i) = I - taup * u * u'
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' and G(i) = I - taup * u * u'
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).
=====================================================================
Test the input parameters
Parameter adjustments
Function Body */
/* Table of constant values */
static complex c_b1 = {1.f,0.f};
static integer c__1 = 1;
static integer c_n1 = -1;
static integer c__3 = 3;
static integer c__2 = 2;
/* System generated locals */
integer a_dim1, a_offset, i__1, i__2, i__3, i__4, i__5;
complex q__1;
/* Local variables */
static integer i, j;
extern /* Subroutine */ int cgemm_(char *, char *, integer *, integer *,
integer *, complex *, complex *, integer *, complex *, integer *,
complex *, complex *, integer *);
static integer nbmin, iinfo, minmn;
extern /* Subroutine */ int cgebd2_(integer *, integer *, complex *,
integer *, real *, real *, complex *, complex *, complex *,
integer *);
static integer nb;
extern /* Subroutine */ int clabrd_(integer *, integer *, integer *,
complex *, integer *, real *, real *, complex *, complex *,
complex *, integer *, complex *, integer *);
static integer nx;
static real ws;
extern /* Subroutine */ int xerbla_(char *, integer *);
extern integer ilaenv_(integer *, char *, char *, integer *, integer *,
integer *, integer *, ftnlen, ftnlen);
static integer ldwrkx, ldwrky;
#define D(I) d[(I)-1]
#define E(I) e[(I)-1]
#define TAUQ(I) tauq[(I)-1]
#define TAUP(I) taup[(I)-1]
#define WORK(I) work[(I)-1]
#define A(I,J) a[(I)-1 + ((J)-1)* ( *lda)]
*info = 0;
if (*m < 0) {
*info = -1;
} else if (*n < 0) {
*info = -2;
} else if (*lda < max(1,*m)) {
*info = -4;
} else /* if(complicated condition) */ {
/* Computing MAX */
i__1 = max(1,*m);
if (*lwork < max(i__1,*n)) {
*info = -10;
}
}
if (*info < 0) {
i__1 = -(*info);
xerbla_("CGEBRD", &i__1);
return 0;
}
/* Quick return if possible */
minmn = min(*m,*n);
if (minmn == 0) {
WORK(1).r = 1.f, WORK(1).i = 0.f;
return 0;
}
ws = (real) max(*m,*n);
ldwrkx = *m;
ldwrky = *n;
/* Set the block size NB and the crossover point NX.
Computing MAX */
i__1 = 1, i__2 = ilaenv_(&c__1, "CGEBRD", " ", m, n, &c_n1, &c_n1, 6L, 1L)
;
nb = max(i__1,i__2);
if (nb > 1 && nb < minmn) {
/* Determine when to switch from blocked to unblocked code.
Computing MAX */
i__1 = nb, i__2 = ilaenv_(&c__3, "CGEBRD", " ", m, n, &c_n1, &c_n1,
6L, 1L);
nx = max(i__1,i__2);
if (nx < minmn) {
ws = (real) ((*m + *n) * nb);
if ((real) (*lwork) < ws) {
/* Not enough work space for the optimal NB, cons
ider using
a smaller block size. */
nbmin = ilaenv_(&c__2, "CGEBRD", " ", m, n, &c_n1, &c_n1, 6L,
1L);
if (*lwork >= (*m + *n) * nbmin) {
nb = *lwork / (*m + *n);
} else {
nb = 1;
nx = minmn;
}
}
}
} else {
nx = minmn;
}
i__1 = minmn - nx;
i__2 = nb;
for (i = 1; nb < 0 ? i >= minmn-nx : i <= minmn-nx; i += nb) {
/* Reduce rows and columns i:i+ib-1 to bidiagonal form and retu
rn
the matrices X and Y which are needed to update the unreduce
d
part of the matrix */
i__3 = *m - i + 1;
i__4 = *n - i + 1;
clabrd_(&i__3, &i__4, &nb, &A(i,i), lda, &D(i), &E(i), &
TAUQ(i), &TAUP(i), &WORK(1), &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' - X*U' */
i__3 = *m - i - nb + 1;
i__4 = *n - i - nb + 1;
q__1.r = -1.f, q__1.i = 0.f;
cgemm_("No transpose", "Conjugate transpose", &i__3, &i__4, &nb, &
q__1, &A(i+nb,i), lda, &WORK(ldwrkx * nb + nb +
1), &ldwrky, &c_b1, &A(i+nb,i+nb), lda);
i__3 = *m - i - nb + 1;
i__4 = *n - i - nb + 1;
q__1.r = -1.f, q__1.i = 0.f;
cgemm_("No transpose", "No transpose", &i__3, &i__4, &nb, &q__1, &
WORK(nb + 1), &ldwrkx, &A(i,i+nb), lda, &c_b1,
&A(i+nb,i+nb), lda);
/* Copy diagonal and off-diagonal elements of B back into A */
if (*m >= *n) {
i__3 = i + nb - 1;
for (j = i; j <= i+nb-1; ++j) {
i__4 = j + j * a_dim1;
i__5 = j;
A(j,j).r = D(j), A(j,j).i = 0.f;
i__4 = j + (j + 1) * a_dim1;
i__5 = j;
A(j,j+1).r = E(j), A(j,j+1).i = 0.f;
/* L10: */
}
} else {
i__3 = i + nb - 1;
for (j = i; j <= i+nb-1; ++j) {
i__4 = j + j * a_dim1;
i__5 = j;
A(j,j).r = D(j), A(j,j).i = 0.f;
i__4 = j + 1 + j * a_dim1;
i__5 = j;
A(j+1,j).r = E(j), A(j+1,j).i = 0.f;
/* L20: */
}
}
/* L30: */
}
/* Use unblocked code to reduce the remainder of the matrix */
i__2 = *m - i + 1;
i__1 = *n - i + 1;
cgebd2_(&i__2, &i__1, &A(i,i), lda, &D(i), &E(i), &TAUQ(i), &
TAUP(i), &WORK(1), &iinfo);
WORK(1).r = ws, WORK(1).i = 0.f;
return 0;
/* End of CGEBRD */
} /* cgebrd_ */
/* Subroutine */ int cgebrd_(integer *m, integer *n, complex *a, integer *lda,
real *d__, real *e, complex *tauq, complex *taup, complex *work,
integer *lwork, integer *info)
{
/* System generated locals */
integer a_dim1, a_offset, i__1, i__2, i__3, i__4, i__5;
real r__1;
complex q__1;
/* Local variables */
integer i__, j, nb, nx;
real ws;
extern /* Subroutine */ int cgemm_(char *, char *, integer *, integer *,
integer *, complex *, complex *, integer *, complex *, integer *,
complex *, complex *, integer *);
integer nbmin, iinfo, minmn;
extern /* Subroutine */ int cgebd2_(integer *, integer *, complex *,
integer *, real *, real *, complex *, complex *, complex *,
integer *), clabrd_(integer *, integer *, integer *, complex *,
integer *, real *, real *, complex *, complex *, complex *,
integer *, complex *, integer *), xerbla_(char *, integer *);
extern integer ilaenv_(integer *, char *, char *, integer *, integer *,
integer *, integer *);
integer ldwrkx, ldwrky, lwkopt;
logical lquery;
/* -- LAPACK routine (version 3.1) -- */
/* Univ. of Tennessee, Univ. of California Berkeley and NAG Ltd.. */
/* November 2006 */
/* .. Scalar Arguments .. */
/* .. */
/* .. Array Arguments .. */
/* .. */
/* 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. */
/* Arguments */
/* ========= */
/* M (input) INTEGER */
/* The number of rows in the matrix A. M >= 0. */
/* N (input) INTEGER */
/* The number of columns in the matrix A. N >= 0. */
/* A (input/output) 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. */
/* LDA (input) INTEGER */
/* The leading dimension of the array A. LDA >= max(1,M). */
/* D (output) REAL array, dimension (min(M,N)) */
/* The diagonal elements of the bidiagonal matrix B: */
/* D(i) = A(i,i). */
/* E (output) 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. */
/* TAUQ (output) COMPLEX array dimension (min(M,N)) */
/* The scalar factors of the elementary reflectors which */
/* represent the unitary matrix Q. See Further Details. */
/* TAUP (output) COMPLEX array, dimension (min(M,N)) */
/* The scalar factors of the elementary reflectors which */
/* represent the unitary matrix P. See Further Details. */
/* WORK (workspace/output) COMPLEX array, dimension (MAX(1,LWORK)) */
/* On exit, if INFO = 0, WORK(1) returns the optimal LWORK. */
/* LWORK (input) 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. */
/* INFO (output) INTEGER */
/* = 0: successful exit. */
/* < 0: if INFO = -i, the i-th argument had an illegal value. */
/* 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' and G(i) = I - taup * u * u' */
/* 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' and G(i) = I - taup * u * u' */
/* 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). */
/* ===================================================================== */
/* .. Parameters .. */
/* .. */
/* .. Local Scalars .. */
/* .. */
/* .. External Subroutines .. */
/* .. */
/* .. Intrinsic Functions .. */
/* .. */
/* .. External Functions .. */
/* .. */
/* .. Executable Statements .. */
/* Test the input parameters */
/* Parameter adjustments */
a_dim1 = *lda;
a_offset = 1 + a_dim1;
a -= a_offset;
--d__;
--e;
--tauq;
--taup;
--work;
/* Function Body */
*info = 0;
/* Computing MAX */
i__1 = 1, i__2 = ilaenv_(&c__1, "CGEBRD", " ", m, n, &c_n1, &c_n1);
nb = max(i__1,i__2);
lwkopt = (*m + *n) * nb;
r__1 = (real) lwkopt;
work[1].r = r__1, work[1].i = 0.f;
lquery = *lwork == -1;
if (*m < 0) {
*info = -1;
} else if (*n < 0) {
*info = -2;
} else if (*lda < max(1,*m)) {
*info = -4;
} else /* if(complicated condition) */ {
/* Computing MAX */
i__1 = max(1,*m);
if (*lwork < max(i__1,*n) && ! lquery) {
*info = -10;
}
}
if (*info < 0) {
i__1 = -(*info);
xerbla_("CGEBRD", &i__1);
return 0;
} else if (lquery) {
return 0;
}
/* Quick return if possible */
minmn = min(*m,*n);
if (minmn == 0) {
work[1].r = 1.f, work[1].i = 0.f;
return 0;
}
ws = (real) max(*m,*n);
ldwrkx = *m;
ldwrky = *n;
if (nb > 1 && nb < minmn) {
/* Set the crossover point NX. */
/* Computing MAX */
i__1 = nb, i__2 = ilaenv_(&c__3, "CGEBRD", " ", m, n, &c_n1, &c_n1);
nx = max(i__1,i__2);
/* Determine when to switch from blocked to unblocked code. */
if (nx < minmn) {
ws = (real) ((*m + *n) * nb);
if ((real) (*lwork) < ws) {
/* Not enough work space for the optimal NB, consider using */
/* a smaller block size. */
nbmin = ilaenv_(&c__2, "CGEBRD", " ", m, n, &c_n1, &c_n1);
if (*lwork >= (*m + *n) * nbmin) {
nb = *lwork / (*m + *n);
} else {
nb = 1;
nx = minmn;
}
}
}
} else {
nx = minmn;
}
i__1 = minmn - nx;
i__2 = nb;
for (i__ = 1; i__2 < 0 ? i__ >= i__1 : i__ <= i__1; i__ += i__2) {
/* 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 */
i__3 = *m - i__ + 1;
i__4 = *n - i__ + 1;
clabrd_(&i__3, &i__4, &nb, &a[i__ + i__ * a_dim1], lda, &d__[i__], &e[
i__], &tauq[i__], &taup[i__], &work[1], &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' - X*U' */
i__3 = *m - i__ - nb + 1;
i__4 = *n - i__ - nb + 1;
q__1.r = -1.f, q__1.i = -0.f;
cgemm_("No transpose", "Conjugate transpose", &i__3, &i__4, &nb, &
q__1, &a[i__ + nb + i__ * a_dim1], lda, &work[ldwrkx * nb +
nb + 1], &ldwrky, &c_b1, &a[i__ + nb + (i__ + nb) * a_dim1],
lda);
i__3 = *m - i__ - nb + 1;
i__4 = *n - i__ - nb + 1;
q__1.r = -1.f, q__1.i = -0.f;
cgemm_("No transpose", "No transpose", &i__3, &i__4, &nb, &q__1, &
work[nb + 1], &ldwrkx, &a[i__ + (i__ + nb) * a_dim1], lda, &
c_b1, &a[i__ + nb + (i__ + nb) * a_dim1], lda);
/* Copy diagonal and off-diagonal elements of B back into A */
if (*m >= *n) {
i__3 = i__ + nb - 1;
for (j = i__; j <= i__3; ++j) {
i__4 = j + j * a_dim1;
i__5 = j;
a[i__4].r = d__[i__5], a[i__4].i = 0.f;
i__4 = j + (j + 1) * a_dim1;
i__5 = j;
a[i__4].r = e[i__5], a[i__4].i = 0.f;
/* L10: */
}
} else {
i__3 = i__ + nb - 1;
for (j = i__; j <= i__3; ++j) {
i__4 = j + j * a_dim1;
i__5 = j;
a[i__4].r = d__[i__5], a[i__4].i = 0.f;
i__4 = j + 1 + j * a_dim1;
i__5 = j;
a[i__4].r = e[i__5], a[i__4].i = 0.f;
/* L20: */
}
}
/* L30: */
}
/* Use unblocked code to reduce the remainder of the matrix */
i__2 = *m - i__ + 1;
i__1 = *n - i__ + 1;
cgebd2_(&i__2, &i__1, &a[i__ + i__ * a_dim1], lda, &d__[i__], &e[i__], &
tauq[i__], &taup[i__], &work[1], &iinfo);
work[1].r = ws, work[1].i = 0.f;
return 0;
/* End of CGEBRD */
} /* cgebrd_ */