/* Subroutine */ int cstt22_(integer *n, integer *m, integer *kband, real *ad,
real *ae, real *sd, real *se, complex *u, integer *ldu, complex *
work, integer *ldwork, real *rwork, real *result)
{
/* System generated locals */
integer u_dim1, u_offset, work_dim1, work_offset, i__1, i__2, i__3, i__4,
i__5, i__6;
real r__1, r__2, r__3, r__4, r__5;
complex q__1, q__2;
/* Local variables */
static complex aukj;
static real unfl;
static integer i__, j, k;
extern /* Subroutine */ int cgemm_(char *, char *, integer *, integer *,
integer *, complex *, complex *, integer *, complex *, integer *,
complex *, complex *, integer *);
static real anorm, wnorm;
extern doublereal clange_(char *, integer *, integer *, complex *,
integer *, real *), slamch_(char *), clansy_(char
*, char *, integer *, complex *, integer *, real *);
static real ulp;
#define work_subscr(a_1,a_2) (a_2)*work_dim1 + a_1
#define work_ref(a_1,a_2) work[work_subscr(a_1,a_2)]
#define u_subscr(a_1,a_2) (a_2)*u_dim1 + a_1
#define u_ref(a_1,a_2) u[u_subscr(a_1,a_2)]
/* -- LAPACK test routine (version 3.0) --
Univ. of Tennessee, Univ. of California Berkeley, NAG Ltd.,
Courant Institute, Argonne National Lab, and Rice University
June 30, 1999
Purpose
=======
CSTT22 checks a set of M eigenvalues and eigenvectors,
A U = U S
where A is Hermitian tridiagonal, the columns of U are unitary,
and S is diagonal (if KBAND=0) or Hermitian tridiagonal (if KBAND=1).
Two tests are performed:
RESULT(1) = | U* A U - S | / ( |A| m ulp )
RESULT(2) = | I - U*U | / ( m ulp )
Arguments
=========
N (input) INTEGER
The size of the matrix. If it is zero, CSTT22 does nothing.
It must be at least zero.
M (input) INTEGER
The number of eigenpairs to check. If it is zero, CSTT22
does nothing. It must be at least zero.
KBAND (input) INTEGER
The bandwidth of the matrix S. It may only be zero or one.
If zero, then S is diagonal, and SE is not referenced. If
one, then S is Hermitian tri-diagonal.
AD (input) REAL array, dimension (N)
The diagonal of the original (unfactored) matrix A. A is
assumed to be Hermitian tridiagonal.
AE (input) REAL array, dimension (N)
The off-diagonal of the original (unfactored) matrix A. A
is assumed to be Hermitian tridiagonal. AE(1) is ignored,
AE(2) is the (1,2) and (2,1) element, etc.
SD (input) REAL array, dimension (N)
The diagonal of the (Hermitian tri-) diagonal matrix S.
SE (input) REAL array, dimension (N)
The off-diagonal of the (Hermitian tri-) diagonal matrix S.
Not referenced if KBSND=0. If KBAND=1, then AE(1) is
ignored, SE(2) is the (1,2) and (2,1) element, etc.
U (input) REAL array, dimension (LDU, N)
The unitary matrix in the decomposition.
LDU (input) INTEGER
The leading dimension of U. LDU must be at least N.
WORK (workspace) COMPLEX array, dimension (LDWORK, M+1)
LDWORK (input) INTEGER
The leading dimension of WORK. LDWORK must be at least
max(1,M).
RWORK (workspace) REAL array, dimension (N)
RESULT (output) REAL array, dimension (2)
The values computed by the two tests described above. The
values are currently limited to 1/ulp, to avoid overflow.
=====================================================================
Parameter adjustments */
--ad;
--ae;
--sd;
--se;
u_dim1 = *ldu;
u_offset = 1 + u_dim1 * 1;
u -= u_offset;
work_dim1 = *ldwork;
work_offset = 1 + work_dim1 * 1;
work -= work_offset;
--rwork;
--result;
/* Function Body */
result[1] = 0.f;
result[2] = 0.f;
if (*n <= 0 || *m <= 0) {
return 0;
}
unfl = slamch_("Safe minimum");
ulp = slamch_("Epsilon");
/* Do Test 1
Compute the 1-norm of A. */
if (*n > 1) {
anorm = dabs(ad[1]) + dabs(ae[1]);
i__1 = *n - 1;
for (j = 2; j <= i__1; ++j) {
/* Computing MAX */
r__4 = anorm, r__5 = (r__1 = ad[j], dabs(r__1)) + (r__2 = ae[j],
dabs(r__2)) + (r__3 = ae[j - 1], dabs(r__3));
anorm = dmax(r__4,r__5);
/* L10: */
}
/* Computing MAX */
r__3 = anorm, r__4 = (r__1 = ad[*n], dabs(r__1)) + (r__2 = ae[*n - 1],
dabs(r__2));
anorm = dmax(r__3,r__4);
} else {
anorm = dabs(ad[1]);
}
anorm = dmax(anorm,unfl);
/* Norm of U*AU - S */
i__1 = *m;
for (i__ = 1; i__ <= i__1; ++i__) {
i__2 = *m;
for (j = 1; j <= i__2; ++j) {
i__3 = work_subscr(i__, j);
work[i__3].r = 0.f, work[i__3].i = 0.f;
i__3 = *n;
for (k = 1; k <= i__3; ++k) {
i__4 = k;
i__5 = u_subscr(k, j);
q__1.r = ad[i__4] * u[i__5].r, q__1.i = ad[i__4] * u[i__5].i;
aukj.r = q__1.r, aukj.i = q__1.i;
if (k != *n) {
i__4 = k;
i__5 = u_subscr(k + 1, j);
q__2.r = ae[i__4] * u[i__5].r, q__2.i = ae[i__4] * u[i__5]
.i;
q__1.r = aukj.r + q__2.r, q__1.i = aukj.i + q__2.i;
aukj.r = q__1.r, aukj.i = q__1.i;
}
if (k != 1) {
i__4 = k - 1;
i__5 = u_subscr(k - 1, j);
q__2.r = ae[i__4] * u[i__5].r, q__2.i = ae[i__4] * u[i__5]
.i;
q__1.r = aukj.r + q__2.r, q__1.i = aukj.i + q__2.i;
aukj.r = q__1.r, aukj.i = q__1.i;
}
i__4 = work_subscr(i__, j);
i__5 = work_subscr(i__, j);
i__6 = u_subscr(k, i__);
q__2.r = u[i__6].r * aukj.r - u[i__6].i * aukj.i, q__2.i = u[
i__6].r * aukj.i + u[i__6].i * aukj.r;
q__1.r = work[i__5].r + q__2.r, q__1.i = work[i__5].i +
q__2.i;
work[i__4].r = q__1.r, work[i__4].i = q__1.i;
/* L20: */
}
/* L30: */
}
i__2 = work_subscr(i__, i__);
i__3 = work_subscr(i__, i__);
i__4 = i__;
q__1.r = work[i__3].r - sd[i__4], q__1.i = work[i__3].i;
work[i__2].r = q__1.r, work[i__2].i = q__1.i;
if (*kband == 1) {
if (i__ != 1) {
i__2 = work_subscr(i__, i__ - 1);
i__3 = work_subscr(i__, i__ - 1);
i__4 = i__ - 1;
q__1.r = work[i__3].r - se[i__4], q__1.i = work[i__3].i;
work[i__2].r = q__1.r, work[i__2].i = q__1.i;
}
if (i__ != *n) {
i__2 = work_subscr(i__, i__ + 1);
i__3 = work_subscr(i__, i__ + 1);
i__4 = i__;
q__1.r = work[i__3].r - se[i__4], q__1.i = work[i__3].i;
work[i__2].r = q__1.r, work[i__2].i = q__1.i;
}
}
/* L40: */
}
wnorm = clansy_("1", "L", m, &work[work_offset], m, &rwork[1]);
if (anorm > wnorm) {
result[1] = wnorm / anorm / (*m * ulp);
} else {
if (anorm < 1.f) {
/* Computing MIN */
r__1 = wnorm, r__2 = *m * anorm;
result[1] = dmin(r__1,r__2) / anorm / (*m * ulp);
} else {
/* Computing MIN */
r__1 = wnorm / anorm, r__2 = (real) (*m);
result[1] = dmin(r__1,r__2) / (*m * ulp);
}
}
/* Do Test 2
Compute U*U - I */
cgemm_("T", "N", m, m, n, &c_b2, &u[u_offset], ldu, &u[u_offset], ldu, &
c_b1, &work[work_offset], m);
i__1 = *m;
for (j = 1; j <= i__1; ++j) {
i__2 = work_subscr(j, j);
i__3 = work_subscr(j, j);
q__1.r = work[i__3].r - 1.f, q__1.i = work[i__3].i;
work[i__2].r = q__1.r, work[i__2].i = q__1.i;
/* L50: */
}
/* Computing MIN */
r__1 = (real) (*m), r__2 = clange_("1", m, m, &work[work_offset], m, &
rwork[1]);
result[2] = dmin(r__1,r__2) / (*m * ulp);
return 0;
/* End of CSTT22 */
} /* cstt22_ */
/* Subroutine */ int ztrsna_(char *job, char *howmny, logical *select,
integer *n, doublecomplex *t, integer *ldt, doublecomplex *vl,
integer *ldvl, doublecomplex *vr, integer *ldvr, doublereal *s,
doublereal *sep, integer *mm, integer *m, doublecomplex *work,
integer *ldwork, doublereal *rwork, integer *info)
{
/* -- LAPACK routine (version 3.0) --
Univ. of Tennessee, Univ. of California Berkeley, NAG Ltd.,
Courant Institute, Argonne National Lab, and Rice University
September 30, 1994
Purpose
=======
ZTRSNA estimates reciprocal condition numbers for specified
eigenvalues and/or right eigenvectors of a complex upper triangular
matrix T (or of any matrix Q*T*Q**H with Q unitary).
Arguments
=========
JOB (input) CHARACTER*1
Specifies whether condition numbers are required for
eigenvalues (S) or eigenvectors (SEP):
= 'E': for eigenvalues only (S);
= 'V': for eigenvectors only (SEP);
= 'B': for both eigenvalues and eigenvectors (S and SEP).
HOWMNY (input) CHARACTER*1
= 'A': compute condition numbers for all eigenpairs;
= 'S': compute condition numbers for selected eigenpairs
specified by the array SELECT.
SELECT (input) LOGICAL array, dimension (N)
If HOWMNY = 'S', SELECT specifies the eigenpairs for which
condition numbers are required. To select condition numbers
for the j-th eigenpair, SELECT(j) must be set to .TRUE..
If HOWMNY = 'A', SELECT is not referenced.
N (input) INTEGER
The order of the matrix T. N >= 0.
T (input) COMPLEX*16 array, dimension (LDT,N)
The upper triangular matrix T.
LDT (input) INTEGER
The leading dimension of the array T. LDT >= max(1,N).
VL (input) COMPLEX*16 array, dimension (LDVL,M)
If JOB = 'E' or 'B', VL must contain left eigenvectors of T
(or of any Q*T*Q**H with Q unitary), corresponding to the
eigenpairs specified by HOWMNY and SELECT. The eigenvectors
must be stored in consecutive columns of VL, as returned by
ZHSEIN or ZTREVC.
If JOB = 'V', VL is not referenced.
LDVL (input) INTEGER
The leading dimension of the array VL.
LDVL >= 1; and if JOB = 'E' or 'B', LDVL >= N.
VR (input) COMPLEX*16 array, dimension (LDVR,M)
If JOB = 'E' or 'B', VR must contain right eigenvectors of T
(or of any Q*T*Q**H with Q unitary), corresponding to the
eigenpairs specified by HOWMNY and SELECT. The eigenvectors
must be stored in consecutive columns of VR, as returned by
ZHSEIN or ZTREVC.
If JOB = 'V', VR is not referenced.
LDVR (input) INTEGER
The leading dimension of the array VR.
LDVR >= 1; and if JOB = 'E' or 'B', LDVR >= N.
S (output) DOUBLE PRECISION array, dimension (MM)
If JOB = 'E' or 'B', the reciprocal condition numbers of the
selected eigenvalues, stored in consecutive elements of the
array. Thus S(j), SEP(j), and the j-th columns of VL and VR
all correspond to the same eigenpair (but not in general the
j-th eigenpair, unless all eigenpairs are selected).
If JOB = 'V', S is not referenced.
SEP (output) DOUBLE PRECISION array, dimension (MM)
If JOB = 'V' or 'B', the estimated reciprocal condition
numbers of the selected eigenvectors, stored in consecutive
elements of the array.
If JOB = 'E', SEP is not referenced.
MM (input) INTEGER
The number of elements in the arrays S (if JOB = 'E' or 'B')
and/or SEP (if JOB = 'V' or 'B'). MM >= M.
M (output) INTEGER
The number of elements of the arrays S and/or SEP actually
used to store the estimated condition numbers.
If HOWMNY = 'A', M is set to N.
WORK (workspace) COMPLEX*16 array, dimension (LDWORK,N+1)
If JOB = 'E', WORK is not referenced.
LDWORK (input) INTEGER
The leading dimension of the array WORK.
LDWORK >= 1; and if JOB = 'V' or 'B', LDWORK >= N.
RWORK (workspace) DOUBLE PRECISION array, dimension (N)
If JOB = 'E', RWORK is not referenced.
INFO (output) INTEGER
= 0: successful exit
< 0: if INFO = -i, the i-th argument had an illegal value
Further Details
===============
The reciprocal of the condition number of an eigenvalue lambda is
defined as
S(lambda) = |v'*u| / (norm(u)*norm(v))
where u and v are the right and left eigenvectors of T corresponding
to lambda; v' denotes the conjugate transpose of v, and norm(u)
denotes the Euclidean norm. These reciprocal condition numbers always
lie between zero (very badly conditioned) and one (very well
conditioned). If n = 1, S(lambda) is defined to be 1.
An approximate error bound for a computed eigenvalue W(i) is given by
EPS * norm(T) / S(i)
where EPS is the machine precision.
The reciprocal of the condition number of the right eigenvector u
corresponding to lambda is defined as follows. Suppose
T = ( lambda c )
( 0 T22 )
Then the reciprocal condition number is
SEP( lambda, T22 ) = sigma-min( T22 - lambda*I )
where sigma-min denotes the smallest singular value. We approximate
the smallest singular value by the reciprocal of an estimate of the
one-norm of the inverse of T22 - lambda*I. If n = 1, SEP(1) is
defined to be abs(T(1,1)).
An approximate error bound for a computed right eigenvector VR(i)
is given by
EPS * norm(T) / SEP(i)
=====================================================================
Decode and test the input parameters
Parameter adjustments */
/* Table of constant values */
static integer c__1 = 1;
/* System generated locals */
integer t_dim1, t_offset, vl_dim1, vl_offset, vr_dim1, vr_offset,
work_dim1, work_offset, i__1, i__2, i__3, i__4, i__5;
doublereal d__1, d__2;
doublecomplex z__1;
/* Builtin functions */
double z_abs(doublecomplex *), d_imag(doublecomplex *);
/* Local variables */
static integer kase, ierr;
static doublecomplex prod;
static doublereal lnrm, rnrm;
static integer i__, j, k;
static doublereal scale;
extern logical lsame_(char *, char *);
extern /* Double Complex */ VOID zdotc_(doublecomplex *, integer *,
doublecomplex *, integer *, doublecomplex *, integer *);
static doublecomplex dummy[1];
static logical wants;
static doublereal xnorm;
extern /* Subroutine */ int dlabad_(doublereal *, doublereal *);
extern doublereal dznrm2_(integer *, doublecomplex *, integer *), dlamch_(
char *);
static integer ks, ix;
extern /* Subroutine */ int xerbla_(char *, integer *);
static doublereal bignum;
static logical wantbh;
extern /* Subroutine */ int zlacon_(integer *, doublecomplex *,
doublecomplex *, doublereal *, integer *);
extern integer izamax_(integer *, doublecomplex *, integer *);
static logical somcon;
extern /* Subroutine */ int zdrscl_(integer *, doublereal *,
doublecomplex *, integer *);
static char normin[1];
extern /* Subroutine */ int zlacpy_(char *, integer *, integer *,
doublecomplex *, integer *, doublecomplex *, integer *);
static doublereal smlnum;
static logical wantsp;
extern /* Subroutine */ int zlatrs_(char *, char *, char *, char *,
integer *, doublecomplex *, integer *, doublecomplex *,
doublereal *, doublereal *, integer *), ztrexc_(char *, integer *, doublecomplex *, integer *,
doublecomplex *, integer *, integer *, integer *, integer *);
static doublereal eps, est;
#define work_subscr(a_1,a_2) (a_2)*work_dim1 + a_1
#define work_ref(a_1,a_2) work[work_subscr(a_1,a_2)]
#define t_subscr(a_1,a_2) (a_2)*t_dim1 + a_1
#define t_ref(a_1,a_2) t[t_subscr(a_1,a_2)]
#define vl_subscr(a_1,a_2) (a_2)*vl_dim1 + a_1
#define vl_ref(a_1,a_2) vl[vl_subscr(a_1,a_2)]
#define vr_subscr(a_1,a_2) (a_2)*vr_dim1 + a_1
#define vr_ref(a_1,a_2) vr[vr_subscr(a_1,a_2)]
--select;
t_dim1 = *ldt;
t_offset = 1 + t_dim1 * 1;
t -= t_offset;
vl_dim1 = *ldvl;
vl_offset = 1 + vl_dim1 * 1;
vl -= vl_offset;
vr_dim1 = *ldvr;
vr_offset = 1 + vr_dim1 * 1;
vr -= vr_offset;
--s;
--sep;
work_dim1 = *ldwork;
work_offset = 1 + work_dim1 * 1;
work -= work_offset;
--rwork;
/* Function Body */
wantbh = lsame_(job, "B");
wants = lsame_(job, "E") || wantbh;
wantsp = lsame_(job, "V") || wantbh;
somcon = lsame_(howmny, "S");
/* Set M to the number of eigenpairs for which condition numbers are
to be computed. */
if (somcon) {
*m = 0;
i__1 = *n;
for (j = 1; j <= i__1; ++j) {
if (select[j]) {
++(*m);
}
/* L10: */
}
} else {
*m = *n;
}
*info = 0;
if (! wants && ! wantsp) {
*info = -1;
} else if (! lsame_(howmny, "A") && ! somcon) {
*info = -2;
} else if (*n < 0) {
*info = -4;
} else if (*ldt < max(1,*n)) {
*info = -6;
} else if (*ldvl < 1 || wants && *ldvl < *n) {
*info = -8;
} else if (*ldvr < 1 || wants && *ldvr < *n) {
*info = -10;
} else if (*mm < *m) {
*info = -13;
} else if (*ldwork < 1 || wantsp && *ldwork < *n) {
*info = -16;
}
if (*info != 0) {
i__1 = -(*info);
xerbla_("ZTRSNA", &i__1);
return 0;
}
/* Quick return if possible */
if (*n == 0) {
return 0;
}
if (*n == 1) {
if (somcon) {
if (! select[1]) {
return 0;
}
}
if (wants) {
s[1] = 1.;
}
if (wantsp) {
sep[1] = z_abs(&t_ref(1, 1));
}
return 0;
}
/* Get machine constants */
eps = dlamch_("P");
smlnum = dlamch_("S") / eps;
bignum = 1. / smlnum;
dlabad_(&smlnum, &bignum);
ks = 1;
i__1 = *n;
for (k = 1; k <= i__1; ++k) {
if (somcon) {
if (! select[k]) {
goto L50;
}
}
if (wants) {
/* Compute the reciprocal condition number of the k-th
eigenvalue. */
zdotc_(&z__1, n, &vr_ref(1, ks), &c__1, &vl_ref(1, ks), &c__1);
prod.r = z__1.r, prod.i = z__1.i;
rnrm = dznrm2_(n, &vr_ref(1, ks), &c__1);
lnrm = dznrm2_(n, &vl_ref(1, ks), &c__1);
s[ks] = z_abs(&prod) / (rnrm * lnrm);
}
if (wantsp) {
/* Estimate the reciprocal condition number of the k-th
eigenvector.
Copy the matrix T to the array WORK and swap the k-th
diagonal element to the (1,1) position. */
zlacpy_("Full", n, n, &t[t_offset], ldt, &work[work_offset],
ldwork);
ztrexc_("No Q", n, &work[work_offset], ldwork, dummy, &c__1, &k, &
c__1, &ierr);
/* Form C = T22 - lambda*I in WORK(2:N,2:N). */
i__2 = *n;
for (i__ = 2; i__ <= i__2; ++i__) {
i__3 = work_subscr(i__, i__);
i__4 = work_subscr(i__, i__);
i__5 = work_subscr(1, 1);
z__1.r = work[i__4].r - work[i__5].r, z__1.i = work[i__4].i -
work[i__5].i;
work[i__3].r = z__1.r, work[i__3].i = z__1.i;
/* L20: */
}
/* Estimate a lower bound for the 1-norm of inv(C'). The 1st
and (N+1)th columns of WORK are used to store work vectors. */
sep[ks] = 0.;
est = 0.;
kase = 0;
*(unsigned char *)normin = 'N';
L30:
i__2 = *n - 1;
zlacon_(&i__2, &work_ref(1, *n + 1), &work[work_offset], &est, &
kase);
if (kase != 0) {
if (kase == 1) {
/* Solve C'*x = scale*b */
i__2 = *n - 1;
zlatrs_("Upper", "Conjugate transpose", "Nonunit", normin,
&i__2, &work_ref(2, 2), ldwork, &work[
work_offset], &scale, &rwork[1], &ierr);
} else {
/* Solve C*x = scale*b */
i__2 = *n - 1;
zlatrs_("Upper", "No transpose", "Nonunit", normin, &i__2,
&work_ref(2, 2), ldwork, &work[work_offset], &
scale, &rwork[1], &ierr);
}
*(unsigned char *)normin = 'Y';
if (scale != 1.) {
/* Multiply by 1/SCALE if doing so will not cause
overflow. */
i__2 = *n - 1;
ix = izamax_(&i__2, &work[work_offset], &c__1);
i__2 = work_subscr(ix, 1);
xnorm = (d__1 = work[i__2].r, abs(d__1)) + (d__2 = d_imag(
&work_ref(ix, 1)), abs(d__2));
if (scale < xnorm * smlnum || scale == 0.) {
goto L40;
}
zdrscl_(n, &scale, &work[work_offset], &c__1);
}
goto L30;
}
sep[ks] = 1. / max(est,smlnum);
}
L40:
++ks;
L50:
;
}
return 0;
/* End of ZTRSNA */
} /* ztrsna_ */
/* Subroutine */ int zpbtrf_(char *uplo, integer *n, integer *kd,
doublecomplex *ab, integer *ldab, integer *info)
{
/* -- LAPACK routine (version 3.0) --
Univ. of Tennessee, Univ. of California Berkeley, NAG Ltd.,
Courant Institute, Argonne National Lab, and Rice University
September 30, 1994
Purpose
=======
ZPBTRF computes the Cholesky factorization of a complex Hermitian
positive definite band matrix A.
The factorization has the form
A = U**H * U, if UPLO = 'U', or
A = L * L**H, if UPLO = 'L',
where U is an upper triangular matrix and L is lower triangular.
Arguments
=========
UPLO (input) CHARACTER*1
= 'U': Upper triangle of A is stored;
= 'L': Lower triangle of A is stored.
N (input) INTEGER
The order of the matrix A. N >= 0.
KD (input) INTEGER
The number of superdiagonals of the matrix A if UPLO = 'U',
or the number of subdiagonals if UPLO = 'L'. KD >= 0.
AB (input/output) COMPLEX*16 array, dimension (LDAB,N)
On entry, the upper or lower triangle of the Hermitian band
matrix A, stored in the first KD+1 rows of the array. The
j-th column of A is stored in the j-th column of the array AB
as follows:
if UPLO = 'U', AB(kd+1+i-j,j) = A(i,j) for max(1,j-kd)<=i<=j;
if UPLO = 'L', AB(1+i-j,j) = A(i,j) for j<=i<=min(n,j+kd).
On exit, if INFO = 0, the triangular factor U or L from the
Cholesky factorization A = U**H*U or A = L*L**H of the band
matrix A, in the same storage format as A.
LDAB (input) INTEGER
The leading dimension of the array AB. LDAB >= KD+1.
INFO (output) INTEGER
= 0: successful exit
< 0: if INFO = -i, the i-th argument had an illegal value
> 0: if INFO = i, the leading minor of order i is not
positive definite, and the factorization could not be
completed.
Further Details
===============
The band storage scheme is illustrated by the following example, when
N = 6, KD = 2, and UPLO = 'U':
On entry: On exit:
* * a13 a24 a35 a46 * * u13 u24 u35 u46
* a12 a23 a34 a45 a56 * u12 u23 u34 u45 u56
a11 a22 a33 a44 a55 a66 u11 u22 u33 u44 u55 u66
Similarly, if UPLO = 'L' the format of A is as follows:
On entry: On exit:
a11 a22 a33 a44 a55 a66 l11 l22 l33 l44 l55 l66
a21 a32 a43 a54 a65 * l21 l32 l43 l54 l65 *
a31 a42 a53 a64 * * l31 l42 l53 l64 * *
Array elements marked * are not used by the routine.
Contributed by
Peter Mayes and Giuseppe Radicati, IBM ECSEC, Rome, March 23, 1989
=====================================================================
Test the input parameters.
Parameter adjustments */
/* Table of constant values */
static doublecomplex c_b1 = {1.,0.};
static integer c__1 = 1;
static integer c_n1 = -1;
static doublereal c_b21 = -1.;
static doublereal c_b22 = 1.;
static integer c__33 = 33;
/* System generated locals */
integer ab_dim1, ab_offset, i__1, i__2, i__3, i__4, i__5, i__6;
doublecomplex z__1;
/* Local variables */
static doublecomplex work[1056] /* was [33][32] */;
static integer i__, j;
extern logical lsame_(char *, char *);
extern /* Subroutine */ int zgemm_(char *, char *, integer *, integer *,
integer *, doublecomplex *, doublecomplex *, integer *,
doublecomplex *, integer *, doublecomplex *, doublecomplex *,
integer *), zherk_(char *, char *, integer *,
integer *, doublereal *, doublecomplex *, integer *, doublereal *,
doublecomplex *, integer *);
static integer i2, i3;
extern /* Subroutine */ int ztrsm_(char *, char *, char *, char *,
integer *, integer *, doublecomplex *, doublecomplex *, integer *,
doublecomplex *, integer *),
zpbtf2_(char *, integer *, integer *, doublecomplex *, integer *,
integer *);
static integer ib, nb, ii, jj;
extern /* Subroutine */ int zpotf2_(char *, integer *, doublecomplex *,
integer *, integer *), xerbla_(char *, integer *);
extern integer ilaenv_(integer *, char *, char *, integer *, integer *,
integer *, integer *, ftnlen, ftnlen);
#define work_subscr(a_1,a_2) (a_2)*33 + a_1 - 34
#define work_ref(a_1,a_2) work[work_subscr(a_1,a_2)]
#define ab_subscr(a_1,a_2) (a_2)*ab_dim1 + a_1
#define ab_ref(a_1,a_2) ab[ab_subscr(a_1,a_2)]
ab_dim1 = *ldab;
ab_offset = 1 + ab_dim1 * 1;
ab -= ab_offset;
/* Function Body */
*info = 0;
if (! lsame_(uplo, "U") && ! lsame_(uplo, "L")) {
*info = -1;
} else if (*n < 0) {
*info = -2;
} else if (*kd < 0) {
*info = -3;
} else if (*ldab < *kd + 1) {
*info = -5;
}
if (*info != 0) {
i__1 = -(*info);
xerbla_("ZPBTRF", &i__1);
return 0;
}
/* Quick return if possible */
if (*n == 0) {
return 0;
}
/* Determine the block size for this environment */
nb = ilaenv_(&c__1, "ZPBTRF", uplo, n, kd, &c_n1, &c_n1, (ftnlen)6, (
ftnlen)1);
/* The block size must not exceed the semi-bandwidth KD, and must not
exceed the limit set by the size of the local array WORK. */
nb = min(nb,32);
if (nb <= 1 || nb > *kd) {
/* Use unblocked code */
zpbtf2_(uplo, n, kd, &ab[ab_offset], ldab, info);
} else {
/* Use blocked code */
if (lsame_(uplo, "U")) {
/* Compute the Cholesky factorization of a Hermitian band
matrix, given the upper triangle of the matrix in band
storage.
Zero the upper triangle of the work array. */
i__1 = nb;
for (j = 1; j <= i__1; ++j) {
i__2 = j - 1;
for (i__ = 1; i__ <= i__2; ++i__) {
i__3 = work_subscr(i__, j);
work[i__3].r = 0., work[i__3].i = 0.;
/* L10: */
}
/* L20: */
}
/* Process the band matrix one diagonal block at a time. */
i__1 = *n;
i__2 = nb;
for (i__ = 1; i__2 < 0 ? i__ >= i__1 : i__ <= i__1; i__ += i__2) {
/* Computing MIN */
i__3 = nb, i__4 = *n - i__ + 1;
ib = min(i__3,i__4);
/* Factorize the diagonal block */
i__3 = *ldab - 1;
zpotf2_(uplo, &ib, &ab_ref(*kd + 1, i__), &i__3, &ii);
if (ii != 0) {
*info = i__ + ii - 1;
goto L150;
}
if (i__ + ib <= *n) {
/* Update the relevant part of the trailing submatrix.
If A11 denotes the diagonal block which has just been
factorized, then we need to update the remaining
blocks in the diagram:
A11 A12 A13
A22 A23
A33
The numbers of rows and columns in the partitioning
are IB, I2, I3 respectively. The blocks A12, A22 and
A23 are empty if IB = KD. The upper triangle of A13
lies outside the band.
Computing MIN */
i__3 = *kd - ib, i__4 = *n - i__ - ib + 1;
i2 = min(i__3,i__4);
/* Computing MIN */
i__3 = ib, i__4 = *n - i__ - *kd + 1;
i3 = min(i__3,i__4);
if (i2 > 0) {
/* Update A12 */
i__3 = *ldab - 1;
i__4 = *ldab - 1;
ztrsm_("Left", "Upper", "Conjugate transpose", "Non-"
"unit", &ib, &i2, &c_b1, &ab_ref(*kd + 1, i__),
&i__3, &ab_ref(*kd + 1 - ib, i__ + ib), &
i__4);
/* Update A22 */
i__3 = *ldab - 1;
i__4 = *ldab - 1;
zherk_("Upper", "Conjugate transpose", &i2, &ib, &
c_b21, &ab_ref(*kd + 1 - ib, i__ + ib), &i__3,
&c_b22, &ab_ref(*kd + 1, i__ + ib), &i__4);
}
if (i3 > 0) {
/* Copy the lower triangle of A13 into the work array. */
i__3 = i3;
for (jj = 1; jj <= i__3; ++jj) {
i__4 = ib;
for (ii = jj; ii <= i__4; ++ii) {
i__5 = work_subscr(ii, jj);
i__6 = ab_subscr(ii - jj + 1, jj + i__ + *kd
- 1);
work[i__5].r = ab[i__6].r, work[i__5].i = ab[
i__6].i;
/* L30: */
}
/* L40: */
}
/* Update A13 (in the work array). */
i__3 = *ldab - 1;
ztrsm_("Left", "Upper", "Conjugate transpose", "Non-"
"unit", &ib, &i3, &c_b1, &ab_ref(*kd + 1, i__),
&i__3, work, &c__33);
/* Update A23 */
if (i2 > 0) {
z__1.r = -1., z__1.i = 0.;
i__3 = *ldab - 1;
i__4 = *ldab - 1;
zgemm_("Conjugate transpose", "No transpose", &i2,
&i3, &ib, &z__1, &ab_ref(*kd + 1 - ib,
i__ + ib), &i__3, work, &c__33, &c_b1, &
ab_ref(ib + 1, i__ + *kd), &i__4);
}
/* Update A33 */
i__3 = *ldab - 1;
zherk_("Upper", "Conjugate transpose", &i3, &ib, &
c_b21, work, &c__33, &c_b22, &ab_ref(*kd + 1,
i__ + *kd), &i__3);
/* Copy the lower triangle of A13 back into place. */
i__3 = i3;
for (jj = 1; jj <= i__3; ++jj) {
i__4 = ib;
for (ii = jj; ii <= i__4; ++ii) {
i__5 = ab_subscr(ii - jj + 1, jj + i__ + *kd
- 1);
i__6 = work_subscr(ii, jj);
ab[i__5].r = work[i__6].r, ab[i__5].i = work[
i__6].i;
/* L50: */
}
/* L60: */
}
}
}
/* L70: */
}
} else {
/* Compute the Cholesky factorization of a Hermitian band
matrix, given the lower triangle of the matrix in band
storage.
Zero the lower triangle of the work array. */
i__2 = nb;
for (j = 1; j <= i__2; ++j) {
i__1 = nb;
for (i__ = j + 1; i__ <= i__1; ++i__) {
i__3 = work_subscr(i__, j);
work[i__3].r = 0., work[i__3].i = 0.;
/* L80: */
}
/* L90: */
}
/* Process the band matrix one diagonal block at a time. */
i__2 = *n;
i__1 = nb;
for (i__ = 1; i__1 < 0 ? i__ >= i__2 : i__ <= i__2; i__ += i__1) {
/* Computing MIN */
i__3 = nb, i__4 = *n - i__ + 1;
ib = min(i__3,i__4);
/* Factorize the diagonal block */
i__3 = *ldab - 1;
zpotf2_(uplo, &ib, &ab_ref(1, i__), &i__3, &ii);
if (ii != 0) {
*info = i__ + ii - 1;
goto L150;
}
if (i__ + ib <= *n) {
/* Update the relevant part of the trailing submatrix.
If A11 denotes the diagonal block which has just been
factorized, then we need to update the remaining
blocks in the diagram:
A11
A21 A22
A31 A32 A33
The numbers of rows and columns in the partitioning
are IB, I2, I3 respectively. The blocks A21, A22 and
A32 are empty if IB = KD. The lower triangle of A31
lies outside the band.
Computing MIN */
i__3 = *kd - ib, i__4 = *n - i__ - ib + 1;
i2 = min(i__3,i__4);
/* Computing MIN */
i__3 = ib, i__4 = *n - i__ - *kd + 1;
i3 = min(i__3,i__4);
if (i2 > 0) {
/* Update A21 */
i__3 = *ldab - 1;
i__4 = *ldab - 1;
ztrsm_("Right", "Lower", "Conjugate transpose", "Non"
"-unit", &i2, &ib, &c_b1, &ab_ref(1, i__), &
i__3, &ab_ref(ib + 1, i__), &i__4);
/* Update A22 */
i__3 = *ldab - 1;
i__4 = *ldab - 1;
zherk_("Lower", "No transpose", &i2, &ib, &c_b21, &
ab_ref(ib + 1, i__), &i__3, &c_b22, &ab_ref(1,
i__ + ib), &i__4);
}
if (i3 > 0) {
/* Copy the upper triangle of A31 into the work array. */
i__3 = ib;
for (jj = 1; jj <= i__3; ++jj) {
i__4 = min(jj,i3);
for (ii = 1; ii <= i__4; ++ii) {
i__5 = work_subscr(ii, jj);
i__6 = ab_subscr(*kd + 1 - jj + ii, jj + i__
- 1);
work[i__5].r = ab[i__6].r, work[i__5].i = ab[
i__6].i;
/* L100: */
}
/* L110: */
}
/* Update A31 (in the work array). */
i__3 = *ldab - 1;
ztrsm_("Right", "Lower", "Conjugate transpose", "Non"
"-unit", &i3, &ib, &c_b1, &ab_ref(1, i__), &
i__3, work, &c__33);
/* Update A32 */
if (i2 > 0) {
z__1.r = -1., z__1.i = 0.;
i__3 = *ldab - 1;
i__4 = *ldab - 1;
zgemm_("No transpose", "Conjugate transpose", &i3,
&i2, &ib, &z__1, work, &c__33, &ab_ref(
ib + 1, i__), &i__3, &c_b1, &ab_ref(*kd +
1 - ib, i__ + ib), &i__4);
}
/* Update A33 */
i__3 = *ldab - 1;
zherk_("Lower", "No transpose", &i3, &ib, &c_b21,
work, &c__33, &c_b22, &ab_ref(1, i__ + *kd), &
i__3);
/* Copy the upper triangle of A31 back into place. */
i__3 = ib;
for (jj = 1; jj <= i__3; ++jj) {
i__4 = min(jj,i3);
for (ii = 1; ii <= i__4; ++ii) {
i__5 = ab_subscr(*kd + 1 - jj + ii, jj + i__
- 1);
i__6 = work_subscr(ii, jj);
ab[i__5].r = work[i__6].r, ab[i__5].i = work[
i__6].i;
/* L120: */
}
/* L130: */
}
}
}
/* L140: */
}
}
}
return 0;
L150:
return 0;
/* End of ZPBTRF */
} /* zpbtrf_ */
/* Subroutine */ int clarfb_(char *side, char *trans, char *direct, char *
storev, integer *m, integer *n, integer *k, complex *v, integer *ldv,
complex *t, integer *ldt, complex *c__, integer *ldc, complex *work,
integer *ldwork)
{
/* -- LAPACK auxiliary routine (version 3.0) --
Univ. of Tennessee, Univ. of California Berkeley, NAG Ltd.,
Courant Institute, Argonne National Lab, and Rice University
September 30, 1994
Purpose
=======
CLARFB applies a complex block reflector H or its transpose H' to a
complex M-by-N matrix C, from either the left or the right.
Arguments
=========
SIDE (input) CHARACTER*1
= 'L': apply H or H' from the Left
= 'R': apply H or H' from the Right
TRANS (input) CHARACTER*1
= 'N': apply H (No transpose)
= 'C': apply H' (Conjugate transpose)
DIRECT (input) CHARACTER*1
Indicates how H is formed from a product of elementary
reflectors
= 'F': H = H(1) H(2) . . . H(k) (Forward)
= 'B': H = H(k) . . . H(2) H(1) (Backward)
STOREV (input) CHARACTER*1
Indicates how the vectors which define the elementary
reflectors are stored:
= 'C': Columnwise
= 'R': Rowwise
M (input) INTEGER
The number of rows of the matrix C.
N (input) INTEGER
The number of columns of the matrix C.
K (input) INTEGER
The order of the matrix T (= the number of elementary
reflectors whose product defines the block reflector).
V (input) COMPLEX array, dimension
(LDV,K) if STOREV = 'C'
(LDV,M) if STOREV = 'R' and SIDE = 'L'
(LDV,N) if STOREV = 'R' and SIDE = 'R'
The matrix V. See further details.
LDV (input) INTEGER
The leading dimension of the array V.
If STOREV = 'C' and SIDE = 'L', LDV >= max(1,M);
if STOREV = 'C' and SIDE = 'R', LDV >= max(1,N);
if STOREV = 'R', LDV >= K.
T (input) COMPLEX array, dimension (LDT,K)
The triangular K-by-K matrix T in the representation of the
block reflector.
LDT (input) INTEGER
The leading dimension of the array T. LDT >= K.
C (input/output) COMPLEX array, dimension (LDC,N)
On entry, the M-by-N matrix C.
On exit, C is overwritten by H*C or H'*C or C*H or C*H'.
LDC (input) INTEGER
The leading dimension of the array C. LDC >= max(1,M).
WORK (workspace) COMPLEX array, dimension (LDWORK,K)
LDWORK (input) INTEGER
The leading dimension of the array WORK.
If SIDE = 'L', LDWORK >= max(1,N);
if SIDE = 'R', LDWORK >= max(1,M).
=====================================================================
Quick return if possible
Parameter adjustments */
/* Table of constant values */
static complex c_b1 = {1.f,0.f};
static integer c__1 = 1;
/* System generated locals */
integer c_dim1, c_offset, t_dim1, t_offset, v_dim1, v_offset, work_dim1,
work_offset, i__1, i__2, i__3, i__4, i__5;
complex q__1, q__2;
/* Builtin functions */
void r_cnjg(complex *, complex *);
/* Local variables */
static integer i__, j;
extern /* Subroutine */ int cgemm_(char *, char *, integer *, integer *,
integer *, complex *, complex *, integer *, complex *, integer *,
complex *, complex *, integer *);
extern logical lsame_(char *, char *);
extern /* Subroutine */ int ccopy_(integer *, complex *, integer *,
complex *, integer *), ctrmm_(char *, char *, char *, char *,
integer *, integer *, complex *, complex *, integer *, complex *,
integer *), clacgv_(integer *,
complex *, integer *);
static char transt[1];
#define work_subscr(a_1,a_2) (a_2)*work_dim1 + a_1
#define work_ref(a_1,a_2) work[work_subscr(a_1,a_2)]
#define c___subscr(a_1,a_2) (a_2)*c_dim1 + a_1
#define c___ref(a_1,a_2) c__[c___subscr(a_1,a_2)]
#define v_subscr(a_1,a_2) (a_2)*v_dim1 + a_1
#define v_ref(a_1,a_2) v[v_subscr(a_1,a_2)]
v_dim1 = *ldv;
v_offset = 1 + v_dim1 * 1;
v -= v_offset;
t_dim1 = *ldt;
t_offset = 1 + t_dim1 * 1;
t -= t_offset;
c_dim1 = *ldc;
c_offset = 1 + c_dim1 * 1;
c__ -= c_offset;
work_dim1 = *ldwork;
work_offset = 1 + work_dim1 * 1;
work -= work_offset;
/* Function Body */
if (*m <= 0 || *n <= 0) {
return 0;
}
if (lsame_(trans, "N")) {
*(unsigned char *)transt = 'C';
} else {
*(unsigned char *)transt = 'N';
}
if (lsame_(storev, "C")) {
if (lsame_(direct, "F")) {
/* Let V = ( V1 ) (first K rows)
( V2 )
where V1 is unit lower triangular. */
if (lsame_(side, "L")) {
/* Form H * C or H' * C where C = ( C1 )
( C2 )
W := C' * V = (C1'*V1 + C2'*V2) (stored in WORK)
W := C1' */
i__1 = *k;
for (j = 1; j <= i__1; ++j) {
ccopy_(n, &c___ref(j, 1), ldc, &work_ref(1, j), &c__1);
clacgv_(n, &work_ref(1, j), &c__1);
/* L10: */
}
/* W := W * V1 */
ctrmm_("Right", "Lower", "No transpose", "Unit", n, k, &c_b1,
&v[v_offset], ldv, &work[work_offset], ldwork);
if (*m > *k) {
/* W := W + C2'*V2 */
i__1 = *m - *k;
cgemm_("Conjugate transpose", "No transpose", n, k, &i__1,
&c_b1, &c___ref(*k + 1, 1), ldc, &v_ref(*k + 1,
1), ldv, &c_b1, &work[work_offset], ldwork);
}
/* W := W * T' or W * T */
ctrmm_("Right", "Upper", transt, "Non-unit", n, k, &c_b1, &t[
t_offset], ldt, &work[work_offset], ldwork);
/* C := C - V * W' */
if (*m > *k) {
/* C2 := C2 - V2 * W' */
i__1 = *m - *k;
q__1.r = -1.f, q__1.i = 0.f;
cgemm_("No transpose", "Conjugate transpose", &i__1, n, k,
&q__1, &v_ref(*k + 1, 1), ldv, &work[work_offset]
, ldwork, &c_b1, &c___ref(*k + 1, 1), ldc);
}
/* W := W * V1' */
ctrmm_("Right", "Lower", "Conjugate transpose", "Unit", n, k,
&c_b1, &v[v_offset], ldv, &work[work_offset], ldwork);
/* C1 := C1 - W' */
i__1 = *k;
for (j = 1; j <= i__1; ++j) {
i__2 = *n;
for (i__ = 1; i__ <= i__2; ++i__) {
i__3 = c___subscr(j, i__);
i__4 = c___subscr(j, i__);
r_cnjg(&q__2, &work_ref(i__, j));
q__1.r = c__[i__4].r - q__2.r, q__1.i = c__[i__4].i -
q__2.i;
c__[i__3].r = q__1.r, c__[i__3].i = q__1.i;
/* L20: */
}
/* L30: */
}
} else if (lsame_(side, "R")) {
/* Form C * H or C * H' where C = ( C1 C2 )
W := C * V = (C1*V1 + C2*V2) (stored in WORK)
W := C1 */
i__1 = *k;
for (j = 1; j <= i__1; ++j) {
ccopy_(m, &c___ref(1, j), &c__1, &work_ref(1, j), &c__1);
/* L40: */
}
/* W := W * V1 */
ctrmm_("Right", "Lower", "No transpose", "Unit", m, k, &c_b1,
&v[v_offset], ldv, &work[work_offset], ldwork);
if (*n > *k) {
/* W := W + C2 * V2 */
i__1 = *n - *k;
cgemm_("No transpose", "No transpose", m, k, &i__1, &c_b1,
&c___ref(1, *k + 1), ldc, &v_ref(*k + 1, 1), ldv,
&c_b1, &work[work_offset], ldwork);
}
/* W := W * T or W * T' */
ctrmm_("Right", "Upper", trans, "Non-unit", m, k, &c_b1, &t[
t_offset], ldt, &work[work_offset], ldwork);
/* C := C - W * V' */
if (*n > *k) {
/* C2 := C2 - W * V2' */
i__1 = *n - *k;
q__1.r = -1.f, q__1.i = 0.f;
cgemm_("No transpose", "Conjugate transpose", m, &i__1, k,
&q__1, &work[work_offset], ldwork, &v_ref(*k + 1,
1), ldv, &c_b1, &c___ref(1, *k + 1), ldc);
}
/* W := W * V1' */
ctrmm_("Right", "Lower", "Conjugate transpose", "Unit", m, k,
&c_b1, &v[v_offset], ldv, &work[work_offset], ldwork);
/* C1 := C1 - W */
i__1 = *k;
for (j = 1; j <= i__1; ++j) {
i__2 = *m;
for (i__ = 1; i__ <= i__2; ++i__) {
i__3 = c___subscr(i__, j);
i__4 = c___subscr(i__, j);
i__5 = work_subscr(i__, j);
q__1.r = c__[i__4].r - work[i__5].r, q__1.i = c__[
i__4].i - work[i__5].i;
c__[i__3].r = q__1.r, c__[i__3].i = q__1.i;
/* L50: */
}
/* L60: */
}
}
} else {
/* Let V = ( V1 )
( V2 ) (last K rows)
where V2 is unit upper triangular. */
if (lsame_(side, "L")) {
/* Form H * C or H' * C where C = ( C1 )
( C2 )
W := C' * V = (C1'*V1 + C2'*V2) (stored in WORK)
W := C2' */
i__1 = *k;
for (j = 1; j <= i__1; ++j) {
ccopy_(n, &c___ref(*m - *k + j, 1), ldc, &work_ref(1, j),
&c__1);
clacgv_(n, &work_ref(1, j), &c__1);
/* L70: */
}
/* W := W * V2 */
ctrmm_("Right", "Upper", "No transpose", "Unit", n, k, &c_b1,
&v_ref(*m - *k + 1, 1), ldv, &work[work_offset],
ldwork);
if (*m > *k) {
/* W := W + C1'*V1 */
i__1 = *m - *k;
cgemm_("Conjugate transpose", "No transpose", n, k, &i__1,
&c_b1, &c__[c_offset], ldc, &v[v_offset], ldv, &
c_b1, &work[work_offset], ldwork);
}
/* W := W * T' or W * T */
ctrmm_("Right", "Lower", transt, "Non-unit", n, k, &c_b1, &t[
t_offset], ldt, &work[work_offset], ldwork);
/* C := C - V * W' */
if (*m > *k) {
/* C1 := C1 - V1 * W' */
i__1 = *m - *k;
q__1.r = -1.f, q__1.i = 0.f;
cgemm_("No transpose", "Conjugate transpose", &i__1, n, k,
&q__1, &v[v_offset], ldv, &work[work_offset],
ldwork, &c_b1, &c__[c_offset], ldc);
}
/* W := W * V2' */
ctrmm_("Right", "Upper", "Conjugate transpose", "Unit", n, k,
&c_b1, &v_ref(*m - *k + 1, 1), ldv, &work[work_offset]
, ldwork)
;
/* C2 := C2 - W' */
i__1 = *k;
for (j = 1; j <= i__1; ++j) {
i__2 = *n;
for (i__ = 1; i__ <= i__2; ++i__) {
i__3 = c___subscr(*m - *k + j, i__);
i__4 = c___subscr(*m - *k + j, i__);
r_cnjg(&q__2, &work_ref(i__, j));
q__1.r = c__[i__4].r - q__2.r, q__1.i = c__[i__4].i -
q__2.i;
c__[i__3].r = q__1.r, c__[i__3].i = q__1.i;
/* L80: */
}
/* L90: */
}
} else if (lsame_(side, "R")) {
/* Form C * H or C * H' where C = ( C1 C2 )
W := C * V = (C1*V1 + C2*V2) (stored in WORK)
W := C2 */
i__1 = *k;
for (j = 1; j <= i__1; ++j) {
ccopy_(m, &c___ref(1, *n - *k + j), &c__1, &work_ref(1, j)
, &c__1);
/* L100: */
}
/* W := W * V2 */
ctrmm_("Right", "Upper", "No transpose", "Unit", m, k, &c_b1,
&v_ref(*n - *k + 1, 1), ldv, &work[work_offset],
ldwork);
if (*n > *k) {
/* W := W + C1 * V1 */
i__1 = *n - *k;
cgemm_("No transpose", "No transpose", m, k, &i__1, &c_b1,
&c__[c_offset], ldc, &v[v_offset], ldv, &c_b1, &
work[work_offset], ldwork)
;
}
/* W := W * T or W * T' */
ctrmm_("Right", "Lower", trans, "Non-unit", m, k, &c_b1, &t[
t_offset], ldt, &work[work_offset], ldwork);
/* C := C - W * V' */
if (*n > *k) {
/* C1 := C1 - W * V1' */
i__1 = *n - *k;
q__1.r = -1.f, q__1.i = 0.f;
cgemm_("No transpose", "Conjugate transpose", m, &i__1, k,
&q__1, &work[work_offset], ldwork, &v[v_offset],
ldv, &c_b1, &c__[c_offset], ldc);
}
/* W := W * V2' */
ctrmm_("Right", "Upper", "Conjugate transpose", "Unit", m, k,
&c_b1, &v_ref(*n - *k + 1, 1), ldv, &work[work_offset]
, ldwork)
;
/* C2 := C2 - W */
i__1 = *k;
for (j = 1; j <= i__1; ++j) {
i__2 = *m;
for (i__ = 1; i__ <= i__2; ++i__) {
i__3 = c___subscr(i__, *n - *k + j);
i__4 = c___subscr(i__, *n - *k + j);
i__5 = work_subscr(i__, j);
q__1.r = c__[i__4].r - work[i__5].r, q__1.i = c__[
i__4].i - work[i__5].i;
c__[i__3].r = q__1.r, c__[i__3].i = q__1.i;
/* L110: */
}
/* L120: */
}
}
}
} else if (lsame_(storev, "R")) {
if (lsame_(direct, "F")) {
/* Let V = ( V1 V2 ) (V1: first K columns)
where V1 is unit upper triangular. */
if (lsame_(side, "L")) {
/* Form H * C or H' * C where C = ( C1 )
( C2 )
W := C' * V' = (C1'*V1' + C2'*V2') (stored in WORK)
W := C1' */
i__1 = *k;
for (j = 1; j <= i__1; ++j) {
ccopy_(n, &c___ref(j, 1), ldc, &work_ref(1, j), &c__1);
clacgv_(n, &work_ref(1, j), &c__1);
/* L130: */
}
/* W := W * V1' */
ctrmm_("Right", "Upper", "Conjugate transpose", "Unit", n, k,
&c_b1, &v[v_offset], ldv, &work[work_offset], ldwork);
if (*m > *k) {
/* W := W + C2'*V2' */
i__1 = *m - *k;
cgemm_("Conjugate transpose", "Conjugate transpose", n, k,
&i__1, &c_b1, &c___ref(*k + 1, 1), ldc, &v_ref(1,
*k + 1), ldv, &c_b1, &work[work_offset], ldwork);
}
/* W := W * T' or W * T */
ctrmm_("Right", "Upper", transt, "Non-unit", n, k, &c_b1, &t[
t_offset], ldt, &work[work_offset], ldwork);
/* C := C - V' * W' */
if (*m > *k) {
/* C2 := C2 - V2' * W' */
i__1 = *m - *k;
q__1.r = -1.f, q__1.i = 0.f;
cgemm_("Conjugate transpose", "Conjugate transpose", &
i__1, n, k, &q__1, &v_ref(1, *k + 1), ldv, &work[
work_offset], ldwork, &c_b1, &c___ref(*k + 1, 1),
ldc);
}
/* W := W * V1 */
ctrmm_("Right", "Upper", "No transpose", "Unit", n, k, &c_b1,
&v[v_offset], ldv, &work[work_offset], ldwork);
/* C1 := C1 - W' */
i__1 = *k;
for (j = 1; j <= i__1; ++j) {
i__2 = *n;
for (i__ = 1; i__ <= i__2; ++i__) {
i__3 = c___subscr(j, i__);
i__4 = c___subscr(j, i__);
r_cnjg(&q__2, &work_ref(i__, j));
q__1.r = c__[i__4].r - q__2.r, q__1.i = c__[i__4].i -
q__2.i;
c__[i__3].r = q__1.r, c__[i__3].i = q__1.i;
/* L140: */
}
/* L150: */
}
} else if (lsame_(side, "R")) {
/* Form C * H or C * H' where C = ( C1 C2 )
W := C * V' = (C1*V1' + C2*V2') (stored in WORK)
W := C1 */
i__1 = *k;
for (j = 1; j <= i__1; ++j) {
ccopy_(m, &c___ref(1, j), &c__1, &work_ref(1, j), &c__1);
/* L160: */
}
/* W := W * V1' */
ctrmm_("Right", "Upper", "Conjugate transpose", "Unit", m, k,
&c_b1, &v[v_offset], ldv, &work[work_offset], ldwork);
if (*n > *k) {
/* W := W + C2 * V2' */
i__1 = *n - *k;
cgemm_("No transpose", "Conjugate transpose", m, k, &i__1,
&c_b1, &c___ref(1, *k + 1), ldc, &v_ref(1, *k +
1), ldv, &c_b1, &work[work_offset], ldwork);
}
/* W := W * T or W * T' */
ctrmm_("Right", "Upper", trans, "Non-unit", m, k, &c_b1, &t[
t_offset], ldt, &work[work_offset], ldwork);
/* C := C - W * V */
if (*n > *k) {
/* C2 := C2 - W * V2 */
i__1 = *n - *k;
q__1.r = -1.f, q__1.i = 0.f;
cgemm_("No transpose", "No transpose", m, &i__1, k, &q__1,
&work[work_offset], ldwork, &v_ref(1, *k + 1),
ldv, &c_b1, &c___ref(1, *k + 1), ldc);
}
/* W := W * V1 */
ctrmm_("Right", "Upper", "No transpose", "Unit", m, k, &c_b1,
&v[v_offset], ldv, &work[work_offset], ldwork);
/* C1 := C1 - W */
i__1 = *k;
for (j = 1; j <= i__1; ++j) {
i__2 = *m;
for (i__ = 1; i__ <= i__2; ++i__) {
i__3 = c___subscr(i__, j);
i__4 = c___subscr(i__, j);
i__5 = work_subscr(i__, j);
q__1.r = c__[i__4].r - work[i__5].r, q__1.i = c__[
i__4].i - work[i__5].i;
c__[i__3].r = q__1.r, c__[i__3].i = q__1.i;
/* L170: */
}
/* L180: */
}
}
} else {
/* Let V = ( V1 V2 ) (V2: last K columns)
where V2 is unit lower triangular. */
if (lsame_(side, "L")) {
/* Form H * C or H' * C where C = ( C1 )
( C2 )
W := C' * V' = (C1'*V1' + C2'*V2') (stored in WORK)
W := C2' */
i__1 = *k;
for (j = 1; j <= i__1; ++j) {
ccopy_(n, &c___ref(*m - *k + j, 1), ldc, &work_ref(1, j),
&c__1);
clacgv_(n, &work_ref(1, j), &c__1);
/* L190: */
}
/* W := W * V2' */
ctrmm_("Right", "Lower", "Conjugate transpose", "Unit", n, k,
&c_b1, &v_ref(1, *m - *k + 1), ldv, &work[work_offset]
, ldwork)
;
if (*m > *k) {
/* W := W + C1'*V1' */
i__1 = *m - *k;
cgemm_("Conjugate transpose", "Conjugate transpose", n, k,
&i__1, &c_b1, &c__[c_offset], ldc, &v[v_offset],
ldv, &c_b1, &work[work_offset], ldwork);
}
/* W := W * T' or W * T */
ctrmm_("Right", "Lower", transt, "Non-unit", n, k, &c_b1, &t[
t_offset], ldt, &work[work_offset], ldwork);
/* C := C - V' * W' */
if (*m > *k) {
/* C1 := C1 - V1' * W' */
i__1 = *m - *k;
q__1.r = -1.f, q__1.i = 0.f;
cgemm_("Conjugate transpose", "Conjugate transpose", &
i__1, n, k, &q__1, &v[v_offset], ldv, &work[
work_offset], ldwork, &c_b1, &c__[c_offset], ldc);
}
/* W := W * V2 */
ctrmm_("Right", "Lower", "No transpose", "Unit", n, k, &c_b1,
&v_ref(1, *m - *k + 1), ldv, &work[work_offset],
ldwork);
/* C2 := C2 - W' */
i__1 = *k;
for (j = 1; j <= i__1; ++j) {
i__2 = *n;
for (i__ = 1; i__ <= i__2; ++i__) {
i__3 = c___subscr(*m - *k + j, i__);
i__4 = c___subscr(*m - *k + j, i__);
r_cnjg(&q__2, &work_ref(i__, j));
q__1.r = c__[i__4].r - q__2.r, q__1.i = c__[i__4].i -
q__2.i;
c__[i__3].r = q__1.r, c__[i__3].i = q__1.i;
/* L200: */
}
/* L210: */
}
} else if (lsame_(side, "R")) {
/* Form C * H or C * H' where C = ( C1 C2 )
W := C * V' = (C1*V1' + C2*V2') (stored in WORK)
W := C2 */
i__1 = *k;
for (j = 1; j <= i__1; ++j) {
ccopy_(m, &c___ref(1, *n - *k + j), &c__1, &work_ref(1, j)
, &c__1);
/* L220: */
}
/* W := W * V2' */
ctrmm_("Right", "Lower", "Conjugate transpose", "Unit", m, k,
&c_b1, &v_ref(1, *n - *k + 1), ldv, &work[work_offset]
, ldwork)
;
if (*n > *k) {
/* W := W + C1 * V1' */
i__1 = *n - *k;
cgemm_("No transpose", "Conjugate transpose", m, k, &i__1,
&c_b1, &c__[c_offset], ldc, &v[v_offset], ldv, &
c_b1, &work[work_offset], ldwork);
}
/* W := W * T or W * T' */
ctrmm_("Right", "Lower", trans, "Non-unit", m, k, &c_b1, &t[
t_offset], ldt, &work[work_offset], ldwork);
/* C := C - W * V */
if (*n > *k) {
/* C1 := C1 - W * V1 */
i__1 = *n - *k;
q__1.r = -1.f, q__1.i = 0.f;
cgemm_("No transpose", "No transpose", m, &i__1, k, &q__1,
&work[work_offset], ldwork, &v[v_offset], ldv, &
c_b1, &c__[c_offset], ldc)
;
}
/* W := W * V2 */
ctrmm_("Right", "Lower", "No transpose", "Unit", m, k, &c_b1,
&v_ref(1, *n - *k + 1), ldv, &work[work_offset],
ldwork);
/* C1 := C1 - W */
i__1 = *k;
for (j = 1; j <= i__1; ++j) {
i__2 = *m;
for (i__ = 1; i__ <= i__2; ++i__) {
i__3 = c___subscr(i__, *n - *k + j);
i__4 = c___subscr(i__, *n - *k + j);
i__5 = work_subscr(i__, j);
q__1.r = c__[i__4].r - work[i__5].r, q__1.i = c__[
i__4].i - work[i__5].i;
c__[i__3].r = q__1.r, c__[i__3].i = q__1.i;
/* L230: */
}
/* L240: */
}
}
}
}
return 0;
/* End of CLARFB */
} /* clarfb_ */