/* DECK INDXC */
/* Subroutine */ int indxc_(integer *i__, integer *ir, integer *idxc, integer
*nc)
{
/* ***BEGIN PROLOGUE INDXC */
/* ***SUBSIDIARY */
/* ***PURPOSE Subsidiary to BLKTRI */
/* ***LIBRARY SLATEC */
/* ***TYPE INTEGER (INDXC-I) */
/* ***AUTHOR (UNKNOWN) */
/* ***SEE ALSO BLKTRI */
/* ***ROUTINES CALLED (NONE) */
/* ***COMMON BLOCKS CBLKT */
/* ***REVISION HISTORY (YYMMDD) */
/* 801001 DATE WRITTEN */
/* 891214 Prologue converted to Version 4.0 format. (BAB) */
/* 900402 Added TYPE section. (WRB) */
/* ***END PROLOGUE INDXC */
/* ***FIRST EXECUTABLE STATEMENT INDXC */
*nc = pow_ii(&c__2, ir);
*idxc = *i__;
if (*idxc + *nc - 1 - cblkt_1.nm <= 0) {
goto L102;
} else {
goto L101;
}
L101:
*nc = 0;
L102:
return 0;
} /* indxc_ */
/* ---------- ------ */
/* Subroutine */ void fcon_cntdif(integer n, double *d)
{
/* Local variables */
integer i, k, k1;
double sc;
integer np1;
/* Generates the coefficients of the central difference formula for */
/* Nth derivative at uniformly spaced points */
d[0] = 1.;
if (n == 0) {
return;
}
for (i = 0; i < n; ++i) {
d[i + 1] = 0.;
for (k = 1; k <= i + 1; ++k) {
k1 = i + 2 - k;
d[k1] = d[k1 - 1] - d[k1];
}
d[0] = -d[0];
}
/* Scale to [0,1] : */
sc = (double) pow_ii(n, n);
np1 = n + 1;
for (i = 0; i < np1; ++i) {
d[i] = sc * d[i];
}
return;
} /* fcon_cntdif_ */
/* Subroutine */ int clalsa_(integer *icompq, integer *smlsiz, integer *n,
integer *nrhs, complex *b, integer *ldb, complex *bx, integer *ldbx,
real *u, integer *ldu, real *vt, integer *k, real *difl, real *difr,
real *z__, real *poles, integer *givptr, integer *givcol, integer *
ldgcol, integer *perm, real *givnum, real *c__, real *s, real *rwork,
integer *iwork, integer *info)
{
/* -- LAPACK 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
=======
CLALSA is an itermediate step in solving the least squares problem
by computing the SVD of the coefficient matrix in compact form (The
singular vectors are computed as products of simple orthorgonal
matrices.).
If ICOMPQ = 0, CLALSA applies the inverse of the left singular vector
matrix of an upper bidiagonal matrix to the right hand side; and if
ICOMPQ = 1, CLALSA applies the right singular vector matrix to the
right hand side. The singular vector matrices were generated in
compact form by CLALSA.
Arguments
=========
ICOMPQ (input) INTEGER
Specifies whether the left or the right singular vector
matrix is involved.
= 0: Left singular vector matrix
= 1: Right singular vector matrix
SMLSIZ (input) INTEGER
The maximum size of the subproblems at the bottom of the
computation tree.
N (input) INTEGER
The row and column dimensions of the upper bidiagonal matrix.
NRHS (input) INTEGER
The number of columns of B and BX. NRHS must be at least 1.
B (input) COMPLEX array, dimension ( LDB, NRHS )
On input, B contains the right hand sides of the least
squares problem in rows 1 through M. On output, B contains
the solution X in rows 1 through N.
LDB (input) INTEGER
The leading dimension of B in the calling subprogram.
LDB must be at least max(1,MAX( M, N ) ).
BX (output) COMPLEX array, dimension ( LDBX, NRHS )
On exit, the result of applying the left or right singular
vector matrix to B.
LDBX (input) INTEGER
The leading dimension of BX.
U (input) REAL array, dimension ( LDU, SMLSIZ ).
On entry, U contains the left singular vector matrices of all
subproblems at the bottom level.
LDU (input) INTEGER, LDU = > N.
The leading dimension of arrays U, VT, DIFL, DIFR,
POLES, GIVNUM, and Z.
VT (input) REAL array, dimension ( LDU, SMLSIZ+1 ).
On entry, VT' contains the right singular vector matrices of
all subproblems at the bottom level.
K (input) INTEGER array, dimension ( N ).
DIFL (input) REAL array, dimension ( LDU, NLVL ).
where NLVL = INT(log_2 (N/(SMLSIZ+1))) + 1.
DIFR (input) REAL array, dimension ( LDU, 2 * NLVL ).
On entry, DIFL(*, I) and DIFR(*, 2 * I -1) record
distances between singular values on the I-th level and
singular values on the (I -1)-th level, and DIFR(*, 2 * I)
record the normalizing factors of the right singular vectors
matrices of subproblems on I-th level.
Z (input) REAL array, dimension ( LDU, NLVL ).
On entry, Z(1, I) contains the components of the deflation-
adjusted updating row vector for subproblems on the I-th
level.
POLES (input) REAL array, dimension ( LDU, 2 * NLVL ).
On entry, POLES(*, 2 * I -1: 2 * I) contains the new and old
singular values involved in the secular equations on the I-th
level.
GIVPTR (input) INTEGER array, dimension ( N ).
On entry, GIVPTR( I ) records the number of Givens
rotations performed on the I-th problem on the computation
tree.
GIVCOL (input) INTEGER array, dimension ( LDGCOL, 2 * NLVL ).
On entry, for each I, GIVCOL(*, 2 * I - 1: 2 * I) records the
locations of Givens rotations performed on the I-th level on
the computation tree.
LDGCOL (input) INTEGER, LDGCOL = > N.
The leading dimension of arrays GIVCOL and PERM.
PERM (input) INTEGER array, dimension ( LDGCOL, NLVL ).
On entry, PERM(*, I) records permutations done on the I-th
level of the computation tree.
GIVNUM (input) REAL array, dimension ( LDU, 2 * NLVL ).
On entry, GIVNUM(*, 2 *I -1 : 2 * I) records the C- and S-
values of Givens rotations performed on the I-th level on the
computation tree.
C (input) REAL array, dimension ( N ).
On entry, if the I-th subproblem is not square,
C( I ) contains the C-value of a Givens rotation related to
the right null space of the I-th subproblem.
S (input) REAL array, dimension ( N ).
On entry, if the I-th subproblem is not square,
S( I ) contains the S-value of a Givens rotation related to
the right null space of the I-th subproblem.
RWORK (workspace) REAL array, dimension at least
max ( N, (SMLSZ+1)*NRHS*3 ).
IWORK (workspace) INTEGER array.
The dimension must be at least 3 * N
INFO (output) INTEGER
= 0: successful exit.
< 0: if INFO = -i, the i-th argument had an illegal value.
Further Details
===============
Based on contributions by
Ming Gu and Ren-Cang Li, Computer Science Division, University of
California at Berkeley, USA
Osni Marques, LBNL/NERSC, USA
=====================================================================
Test the input parameters.
Parameter adjustments */
/* Table of constant values */
static real c_b9 = 1.f;
static real c_b10 = 0.f;
static integer c__2 = 2;
/* System generated locals */
integer givcol_dim1, givcol_offset, perm_dim1, perm_offset, difl_dim1,
difl_offset, difr_dim1, difr_offset, givnum_dim1, givnum_offset,
poles_dim1, poles_offset, u_dim1, u_offset, vt_dim1, vt_offset,
z_dim1, z_offset, b_dim1, b_offset, bx_dim1, bx_offset, i__1,
i__2, i__3, i__4, i__5, i__6;
complex q__1;
/* Builtin functions */
double r_imag(complex *);
integer pow_ii(integer *, integer *);
/* Local variables */
static integer jcol, nlvl, sqre, jrow, i__, j, jimag, jreal, inode, ndiml;
extern /* Subroutine */ int sgemm_(char *, char *, integer *, integer *,
integer *, real *, real *, integer *, real *, integer *, real *,
real *, integer *);
static integer ndimr;
extern /* Subroutine */ int ccopy_(integer *, complex *, integer *,
complex *, integer *);
static integer i1;
extern /* Subroutine */ int clals0_(integer *, integer *, integer *,
integer *, integer *, complex *, integer *, complex *, integer *,
integer *, integer *, integer *, integer *, real *, integer *,
real *, real *, real *, real *, integer *, real *, real *, real *,
integer *);
static integer ic, lf, nd, ll, nl, nr;
extern /* Subroutine */ int xerbla_(char *, integer *), slasdt_(
integer *, integer *, integer *, integer *, integer *, integer *,
integer *);
static integer im1, nlf, nrf, lvl, ndb1, nlp1, lvl2, nrp1;
#define difl_ref(a_1,a_2) difl[(a_2)*difl_dim1 + a_1]
#define difr_ref(a_1,a_2) difr[(a_2)*difr_dim1 + a_1]
#define perm_ref(a_1,a_2) perm[(a_2)*perm_dim1 + a_1]
#define b_subscr(a_1,a_2) (a_2)*b_dim1 + a_1
#define b_ref(a_1,a_2) b[b_subscr(a_1,a_2)]
#define u_ref(a_1,a_2) u[(a_2)*u_dim1 + a_1]
#define z___ref(a_1,a_2) z__[(a_2)*z_dim1 + a_1]
#define poles_ref(a_1,a_2) poles[(a_2)*poles_dim1 + a_1]
#define bx_subscr(a_1,a_2) (a_2)*bx_dim1 + a_1
#define bx_ref(a_1,a_2) bx[bx_subscr(a_1,a_2)]
#define vt_ref(a_1,a_2) vt[(a_2)*vt_dim1 + a_1]
#define givcol_ref(a_1,a_2) givcol[(a_2)*givcol_dim1 + a_1]
#define givnum_ref(a_1,a_2) givnum[(a_2)*givnum_dim1 + a_1]
b_dim1 = *ldb;
b_offset = 1 + b_dim1 * 1;
b -= b_offset;
bx_dim1 = *ldbx;
bx_offset = 1 + bx_dim1 * 1;
bx -= bx_offset;
givnum_dim1 = *ldu;
givnum_offset = 1 + givnum_dim1 * 1;
givnum -= givnum_offset;
poles_dim1 = *ldu;
poles_offset = 1 + poles_dim1 * 1;
poles -= poles_offset;
z_dim1 = *ldu;
z_offset = 1 + z_dim1 * 1;
z__ -= z_offset;
difr_dim1 = *ldu;
difr_offset = 1 + difr_dim1 * 1;
difr -= difr_offset;
difl_dim1 = *ldu;
difl_offset = 1 + difl_dim1 * 1;
difl -= difl_offset;
vt_dim1 = *ldu;
vt_offset = 1 + vt_dim1 * 1;
vt -= vt_offset;
u_dim1 = *ldu;
u_offset = 1 + u_dim1 * 1;
u -= u_offset;
--k;
--givptr;
perm_dim1 = *ldgcol;
perm_offset = 1 + perm_dim1 * 1;
perm -= perm_offset;
givcol_dim1 = *ldgcol;
givcol_offset = 1 + givcol_dim1 * 1;
givcol -= givcol_offset;
--c__;
--s;
--rwork;
--iwork;
/* Function Body */
*info = 0;
if (*icompq < 0 || *icompq > 1) {
*info = -1;
} else if (*smlsiz < 3) {
*info = -2;
} else if (*n < *smlsiz) {
*info = -3;
} else if (*nrhs < 1) {
*info = -4;
} else if (*ldb < *n) {
*info = -6;
} else if (*ldbx < *n) {
*info = -8;
} else if (*ldu < *n) {
*info = -10;
} else if (*ldgcol < *n) {
*info = -19;
}
if (*info != 0) {
i__1 = -(*info);
xerbla_("CLALSA", &i__1);
return 0;
}
/* Book-keeping and setting up the computation tree. */
inode = 1;
ndiml = inode + *n;
ndimr = ndiml + *n;
slasdt_(n, &nlvl, &nd, &iwork[inode], &iwork[ndiml], &iwork[ndimr],
smlsiz);
/* The following code applies back the left singular vector factors.
For applying back the right singular vector factors, go to 170. */
if (*icompq == 1) {
goto L170;
}
/* The nodes on the bottom level of the tree were solved
by SLASDQ. The corresponding left and right singular vector
matrices are in explicit form. First apply back the left
singular vector matrices. */
ndb1 = (nd + 1) / 2;
i__1 = nd;
for (i__ = ndb1; i__ <= i__1; ++i__) {
/* IC : center row of each node
NL : number of rows of left subproblem
NR : number of rows of right subproblem
NLF: starting row of the left subproblem
NRF: starting row of the right subproblem */
i1 = i__ - 1;
ic = iwork[inode + i1];
nl = iwork[ndiml + i1];
nr = iwork[ndimr + i1];
nlf = ic - nl;
nrf = ic + 1;
/* Since B and BX are complex, the following call to SGEMM
is performed in two steps (real and imaginary parts).
CALL SGEMM( 'T', 'N', NL, NRHS, NL, ONE, U( NLF, 1 ), LDU,
$ B( NLF, 1 ), LDB, ZERO, BX( NLF, 1 ), LDBX ) */
j = nl * *nrhs << 1;
i__2 = *nrhs;
for (jcol = 1; jcol <= i__2; ++jcol) {
i__3 = nlf + nl - 1;
for (jrow = nlf; jrow <= i__3; ++jrow) {
++j;
i__4 = b_subscr(jrow, jcol);
rwork[j] = b[i__4].r;
/* L10: */
}
/* L20: */
}
sgemm_("T", "N", &nl, nrhs, &nl, &c_b9, &u_ref(nlf, 1), ldu, &rwork[(
nl * *nrhs << 1) + 1], &nl, &c_b10, &rwork[1], &nl);
j = nl * *nrhs << 1;
i__2 = *nrhs;
for (jcol = 1; jcol <= i__2; ++jcol) {
i__3 = nlf + nl - 1;
for (jrow = nlf; jrow <= i__3; ++jrow) {
++j;
rwork[j] = r_imag(&b_ref(jrow, jcol));
/* L30: */
}
/* L40: */
}
sgemm_("T", "N", &nl, nrhs, &nl, &c_b9, &u_ref(nlf, 1), ldu, &rwork[(
nl * *nrhs << 1) + 1], &nl, &c_b10, &rwork[nl * *nrhs + 1], &
nl);
jreal = 0;
jimag = nl * *nrhs;
i__2 = *nrhs;
for (jcol = 1; jcol <= i__2; ++jcol) {
i__3 = nlf + nl - 1;
for (jrow = nlf; jrow <= i__3; ++jrow) {
++jreal;
++jimag;
i__4 = bx_subscr(jrow, jcol);
i__5 = jreal;
i__6 = jimag;
q__1.r = rwork[i__5], q__1.i = rwork[i__6];
bx[i__4].r = q__1.r, bx[i__4].i = q__1.i;
/* L50: */
}
/* L60: */
}
/* Since B and BX are complex, the following call to SGEMM
is performed in two steps (real and imaginary parts).
CALL SGEMM( 'T', 'N', NR, NRHS, NR, ONE, U( NRF, 1 ), LDU,
$ B( NRF, 1 ), LDB, ZERO, BX( NRF, 1 ), LDBX ) */
j = nr * *nrhs << 1;
i__2 = *nrhs;
for (jcol = 1; jcol <= i__2; ++jcol) {
i__3 = nrf + nr - 1;
for (jrow = nrf; jrow <= i__3; ++jrow) {
++j;
i__4 = b_subscr(jrow, jcol);
rwork[j] = b[i__4].r;
/* L70: */
}
/* L80: */
}
sgemm_("T", "N", &nr, nrhs, &nr, &c_b9, &u_ref(nrf, 1), ldu, &rwork[(
nr * *nrhs << 1) + 1], &nr, &c_b10, &rwork[1], &nr);
j = nr * *nrhs << 1;
i__2 = *nrhs;
for (jcol = 1; jcol <= i__2; ++jcol) {
i__3 = nrf + nr - 1;
for (jrow = nrf; jrow <= i__3; ++jrow) {
++j;
rwork[j] = r_imag(&b_ref(jrow, jcol));
/* L90: */
}
/* L100: */
}
sgemm_("T", "N", &nr, nrhs, &nr, &c_b9, &u_ref(nrf, 1), ldu, &rwork[(
nr * *nrhs << 1) + 1], &nr, &c_b10, &rwork[nr * *nrhs + 1], &
nr);
jreal = 0;
jimag = nr * *nrhs;
i__2 = *nrhs;
for (jcol = 1; jcol <= i__2; ++jcol) {
i__3 = nrf + nr - 1;
for (jrow = nrf; jrow <= i__3; ++jrow) {
++jreal;
++jimag;
i__4 = bx_subscr(jrow, jcol);
i__5 = jreal;
i__6 = jimag;
q__1.r = rwork[i__5], q__1.i = rwork[i__6];
bx[i__4].r = q__1.r, bx[i__4].i = q__1.i;
/* L110: */
}
/* L120: */
}
/* L130: */
}
/* Next copy the rows of B that correspond to unchanged rows
in the bidiagonal matrix to BX. */
i__1 = nd;
for (i__ = 1; i__ <= i__1; ++i__) {
ic = iwork[inode + i__ - 1];
ccopy_(nrhs, &b_ref(ic, 1), ldb, &bx_ref(ic, 1), ldbx);
/* L140: */
}
/* Finally go through the left singular vector matrices of all
the other subproblems bottom-up on the tree. */
j = pow_ii(&c__2, &nlvl);
sqre = 0;
for (lvl = nlvl; lvl >= 1; --lvl) {
lvl2 = (lvl << 1) - 1;
/* find the first node LF and last node LL on
the current level LVL */
if (lvl == 1) {
lf = 1;
ll = 1;
} else {
i__1 = lvl - 1;
lf = pow_ii(&c__2, &i__1);
ll = (lf << 1) - 1;
}
i__1 = ll;
for (i__ = lf; i__ <= i__1; ++i__) {
im1 = i__ - 1;
ic = iwork[inode + im1];
nl = iwork[ndiml + im1];
nr = iwork[ndimr + im1];
nlf = ic - nl;
nrf = ic + 1;
--j;
clals0_(icompq, &nl, &nr, &sqre, nrhs, &bx_ref(nlf, 1), ldbx, &
b_ref(nlf, 1), ldb, &perm_ref(nlf, lvl), &givptr[j], &
givcol_ref(nlf, lvl2), ldgcol, &givnum_ref(nlf, lvl2),
ldu, &poles_ref(nlf, lvl2), &difl_ref(nlf, lvl), &
difr_ref(nlf, lvl2), &z___ref(nlf, lvl), &k[j], &c__[j], &
s[j], &rwork[1], info);
/* L150: */
}
/* L160: */
}
goto L330;
/* ICOMPQ = 1: applying back the right singular vector factors. */
L170:
/* First now go through the right singular vector matrices of all
the tree nodes top-down. */
j = 0;
i__1 = nlvl;
for (lvl = 1; lvl <= i__1; ++lvl) {
lvl2 = (lvl << 1) - 1;
/* Find the first node LF and last node LL on
the current level LVL. */
if (lvl == 1) {
lf = 1;
ll = 1;
} else {
i__2 = lvl - 1;
lf = pow_ii(&c__2, &i__2);
ll = (lf << 1) - 1;
}
i__2 = lf;
for (i__ = ll; i__ >= i__2; --i__) {
im1 = i__ - 1;
ic = iwork[inode + im1];
nl = iwork[ndiml + im1];
nr = iwork[ndimr + im1];
nlf = ic - nl;
nrf = ic + 1;
if (i__ == ll) {
sqre = 0;
} else {
sqre = 1;
}
++j;
clals0_(icompq, &nl, &nr, &sqre, nrhs, &b_ref(nlf, 1), ldb, &
bx_ref(nlf, 1), ldbx, &perm_ref(nlf, lvl), &givptr[j], &
givcol_ref(nlf, lvl2), ldgcol, &givnum_ref(nlf, lvl2),
ldu, &poles_ref(nlf, lvl2), &difl_ref(nlf, lvl), &
difr_ref(nlf, lvl2), &z___ref(nlf, lvl), &k[j], &c__[j], &
s[j], &rwork[1], info);
/* L180: */
}
/* L190: */
}
/* The nodes on the bottom level of the tree were solved
by SLASDQ. The corresponding right singular vector
matrices are in explicit form. Apply them back. */
ndb1 = (nd + 1) / 2;
i__1 = nd;
for (i__ = ndb1; i__ <= i__1; ++i__) {
i1 = i__ - 1;
ic = iwork[inode + i1];
nl = iwork[ndiml + i1];
nr = iwork[ndimr + i1];
nlp1 = nl + 1;
if (i__ == nd) {
nrp1 = nr;
} else {
nrp1 = nr + 1;
}
nlf = ic - nl;
nrf = ic + 1;
/* Since B and BX are complex, the following call to SGEMM is
performed in two steps (real and imaginary parts).
CALL SGEMM( 'T', 'N', NLP1, NRHS, NLP1, ONE, VT( NLF, 1 ), LDU,
$ B( NLF, 1 ), LDB, ZERO, BX( NLF, 1 ), LDBX ) */
j = nlp1 * *nrhs << 1;
i__2 = *nrhs;
for (jcol = 1; jcol <= i__2; ++jcol) {
i__3 = nlf + nlp1 - 1;
for (jrow = nlf; jrow <= i__3; ++jrow) {
++j;
i__4 = b_subscr(jrow, jcol);
rwork[j] = b[i__4].r;
/* L200: */
}
/* L210: */
}
sgemm_("T", "N", &nlp1, nrhs, &nlp1, &c_b9, &vt_ref(nlf, 1), ldu, &
rwork[(nlp1 * *nrhs << 1) + 1], &nlp1, &c_b10, &rwork[1], &
nlp1);
j = nlp1 * *nrhs << 1;
i__2 = *nrhs;
for (jcol = 1; jcol <= i__2; ++jcol) {
i__3 = nlf + nlp1 - 1;
for (jrow = nlf; jrow <= i__3; ++jrow) {
++j;
rwork[j] = r_imag(&b_ref(jrow, jcol));
/* L220: */
}
/* L230: */
}
sgemm_("T", "N", &nlp1, nrhs, &nlp1, &c_b9, &vt_ref(nlf, 1), ldu, &
rwork[(nlp1 * *nrhs << 1) + 1], &nlp1, &c_b10, &rwork[nlp1 * *
nrhs + 1], &nlp1);
jreal = 0;
jimag = nlp1 * *nrhs;
i__2 = *nrhs;
for (jcol = 1; jcol <= i__2; ++jcol) {
i__3 = nlf + nlp1 - 1;
for (jrow = nlf; jrow <= i__3; ++jrow) {
++jreal;
++jimag;
i__4 = bx_subscr(jrow, jcol);
i__5 = jreal;
i__6 = jimag;
q__1.r = rwork[i__5], q__1.i = rwork[i__6];
bx[i__4].r = q__1.r, bx[i__4].i = q__1.i;
/* L240: */
}
/* L250: */
}
/* Since B and BX are complex, the following call to SGEMM is
performed in two steps (real and imaginary parts).
CALL SGEMM( 'T', 'N', NRP1, NRHS, NRP1, ONE, VT( NRF, 1 ), LDU,
$ B( NRF, 1 ), LDB, ZERO, BX( NRF, 1 ), LDBX ) */
j = nrp1 * *nrhs << 1;
i__2 = *nrhs;
for (jcol = 1; jcol <= i__2; ++jcol) {
i__3 = nrf + nrp1 - 1;
for (jrow = nrf; jrow <= i__3; ++jrow) {
++j;
i__4 = b_subscr(jrow, jcol);
rwork[j] = b[i__4].r;
/* L260: */
}
/* L270: */
}
sgemm_("T", "N", &nrp1, nrhs, &nrp1, &c_b9, &vt_ref(nrf, 1), ldu, &
rwork[(nrp1 * *nrhs << 1) + 1], &nrp1, &c_b10, &rwork[1], &
nrp1);
j = nrp1 * *nrhs << 1;
i__2 = *nrhs;
for (jcol = 1; jcol <= i__2; ++jcol) {
i__3 = nrf + nrp1 - 1;
for (jrow = nrf; jrow <= i__3; ++jrow) {
++j;
rwork[j] = r_imag(&b_ref(jrow, jcol));
/* L280: */
}
/* L290: */
}
sgemm_("T", "N", &nrp1, nrhs, &nrp1, &c_b9, &vt_ref(nrf, 1), ldu, &
rwork[(nrp1 * *nrhs << 1) + 1], &nrp1, &c_b10, &rwork[nrp1 * *
nrhs + 1], &nrp1);
jreal = 0;
jimag = nrp1 * *nrhs;
i__2 = *nrhs;
for (jcol = 1; jcol <= i__2; ++jcol) {
i__3 = nrf + nrp1 - 1;
for (jrow = nrf; jrow <= i__3; ++jrow) {
++jreal;
++jimag;
i__4 = bx_subscr(jrow, jcol);
i__5 = jreal;
i__6 = jimag;
q__1.r = rwork[i__5], q__1.i = rwork[i__6];
bx[i__4].r = q__1.r, bx[i__4].i = q__1.i;
/* L300: */
}
/* L310: */
}
/* L320: */
}
L330:
return 0;
/* End of CLALSA */
} /* clalsa_ */
/* Subroutine */ int dlasda_(integer *icompq, integer *smlsiz, integer *n,
integer *sqre, doublereal *d__, doublereal *e, doublereal *u, integer
*ldu, doublereal *vt, integer *k, doublereal *difl, doublereal *difr,
doublereal *z__, doublereal *poles, integer *givptr, integer *givcol,
integer *ldgcol, integer *perm, doublereal *givnum, doublereal *c__,
doublereal *s, doublereal *work, integer *iwork, integer *info)
{
/* System generated locals */
integer givcol_dim1, givcol_offset, perm_dim1, perm_offset, difl_dim1,
difl_offset, difr_dim1, difr_offset, givnum_dim1, givnum_offset,
poles_dim1, poles_offset, u_dim1, u_offset, vt_dim1, vt_offset,
z_dim1, z_offset, i__1, i__2;
/* Builtin functions */
integer pow_ii(integer *, integer *);
/* Local variables */
static doublereal beta;
static integer idxq, nlvl, i__, j, m;
static doublereal alpha;
static integer inode, ndiml, ndimr, idxqi, itemp;
extern /* Subroutine */ int dcopy_(integer *, doublereal *, integer *,
doublereal *, integer *);
static integer sqrei, i1;
extern /* Subroutine */ int dlasd6_(integer *, integer *, integer *,
integer *, doublereal *, doublereal *, doublereal *, doublereal *,
doublereal *, integer *, integer *, integer *, integer *,
integer *, doublereal *, integer *, doublereal *, doublereal *,
doublereal *, doublereal *, integer *, doublereal *, doublereal *,
doublereal *, integer *, integer *);
static integer ic, nwork1, lf, nd, nwork2, ll, nl, vf, nr, vl;
extern /* Subroutine */ int dlasdq_(char *, integer *, integer *, integer
*, integer *, integer *, doublereal *, doublereal *, doublereal *,
integer *, doublereal *, integer *, doublereal *, integer *,
doublereal *, integer *), dlasdt_(integer *, integer *,
integer *, integer *, integer *, integer *, integer *), dlaset_(
char *, integer *, integer *, doublereal *, doublereal *,
doublereal *, integer *), xerbla_(char *, integer *);
static integer im1, smlszp, ncc, nlf, nrf, vfi, iwk, vli, lvl, nru, ndb1,
nlp1, lvl2, nrp1;
#define difl_ref(a_1,a_2) difl[(a_2)*difl_dim1 + a_1]
#define difr_ref(a_1,a_2) difr[(a_2)*difr_dim1 + a_1]
#define perm_ref(a_1,a_2) perm[(a_2)*perm_dim1 + a_1]
#define u_ref(a_1,a_2) u[(a_2)*u_dim1 + a_1]
#define z___ref(a_1,a_2) z__[(a_2)*z_dim1 + a_1]
#define poles_ref(a_1,a_2) poles[(a_2)*poles_dim1 + a_1]
#define vt_ref(a_1,a_2) vt[(a_2)*vt_dim1 + a_1]
#define givcol_ref(a_1,a_2) givcol[(a_2)*givcol_dim1 + a_1]
#define givnum_ref(a_1,a_2) givnum[(a_2)*givnum_dim1 + a_1]
/* -- LAPACK auxiliary routine (version 3.0) --
Univ. of Tennessee, Univ. of California Berkeley, NAG Ltd.,
Courant Institute, Argonne National Lab, and Rice University
October 31, 1999
Purpose
=======
Using a divide and conquer approach, DLASDA computes the singular
value decomposition (SVD) of a real upper bidiagonal N-by-M matrix
B with diagonal D and offdiagonal E, where M = N + SQRE. The
algorithm computes the singular values in the SVD B = U * S * VT.
The orthogonal matrices U and VT are optionally computed in
compact form.
A related subroutine, DLASD0, computes the singular values and
the singular vectors in explicit form.
Arguments
=========
ICOMPQ (input) INTEGER
Specifies whether singular vectors are to be computed
in compact form, as follows
= 0: Compute singular values only.
= 1: Compute singular vectors of upper bidiagonal
matrix in compact form.
SMLSIZ (input) INTEGER
The maximum size of the subproblems at the bottom of the
computation tree.
N (input) INTEGER
The row dimension of the upper bidiagonal matrix. This is
also the dimension of the main diagonal array D.
SQRE (input) INTEGER
Specifies the column dimension of the bidiagonal matrix.
= 0: The bidiagonal matrix has column dimension M = N;
= 1: The bidiagonal matrix has column dimension M = N + 1.
D (input/output) DOUBLE PRECISION array, dimension ( N )
On entry D contains the main diagonal of the bidiagonal
matrix. On exit D, if INFO = 0, contains its singular values.
E (input) DOUBLE PRECISION array, dimension ( M-1 )
Contains the subdiagonal entries of the bidiagonal matrix.
On exit, E has been destroyed.
U (output) DOUBLE PRECISION array,
dimension ( LDU, SMLSIZ ) if ICOMPQ = 1, and not referenced
if ICOMPQ = 0. If ICOMPQ = 1, on exit, U contains the left
singular vector matrices of all subproblems at the bottom
level.
LDU (input) INTEGER, LDU = > N.
The leading dimension of arrays U, VT, DIFL, DIFR, POLES,
GIVNUM, and Z.
VT (output) DOUBLE PRECISION array,
dimension ( LDU, SMLSIZ+1 ) if ICOMPQ = 1, and not referenced
if ICOMPQ = 0. If ICOMPQ = 1, on exit, VT' contains the right
singular vector matrices of all subproblems at the bottom
level.
K (output) INTEGER array,
dimension ( N ) if ICOMPQ = 1 and dimension 1 if ICOMPQ = 0.
If ICOMPQ = 1, on exit, K(I) is the dimension of the I-th
secular equation on the computation tree.
DIFL (output) DOUBLE PRECISION array, dimension ( LDU, NLVL ),
where NLVL = floor(log_2 (N/SMLSIZ))).
DIFR (output) DOUBLE PRECISION array,
dimension ( LDU, 2 * NLVL ) if ICOMPQ = 1 and
dimension ( N ) if ICOMPQ = 0.
If ICOMPQ = 1, on exit, DIFL(1:N, I) and DIFR(1:N, 2 * I - 1)
record distances between singular values on the I-th
level and singular values on the (I -1)-th level, and
DIFR(1:N, 2 * I ) contains the normalizing factors for
the right singular vector matrix. See DLASD8 for details.
Z (output) DOUBLE PRECISION array,
dimension ( LDU, NLVL ) if ICOMPQ = 1 and
dimension ( N ) if ICOMPQ = 0.
The first K elements of Z(1, I) contain the components of
the deflation-adjusted updating row vector for subproblems
on the I-th level.
POLES (output) DOUBLE PRECISION array,
dimension ( LDU, 2 * NLVL ) if ICOMPQ = 1, and not referenced
if ICOMPQ = 0. If ICOMPQ = 1, on exit, POLES(1, 2*I - 1) and
POLES(1, 2*I) contain the new and old singular values
involved in the secular equations on the I-th level.
GIVPTR (output) INTEGER array,
dimension ( N ) if ICOMPQ = 1, and not referenced if
ICOMPQ = 0. If ICOMPQ = 1, on exit, GIVPTR( I ) records
the number of Givens rotations performed on the I-th
problem on the computation tree.
GIVCOL (output) INTEGER array,
dimension ( LDGCOL, 2 * NLVL ) if ICOMPQ = 1, and not
referenced if ICOMPQ = 0. If ICOMPQ = 1, on exit, for each I,
GIVCOL(1, 2 *I - 1) and GIVCOL(1, 2 *I) record the locations
of Givens rotations performed on the I-th level on the
computation tree.
LDGCOL (input) INTEGER, LDGCOL = > N.
The leading dimension of arrays GIVCOL and PERM.
PERM (output) INTEGER array,
dimension ( LDGCOL, NLVL ) if ICOMPQ = 1, and not referenced
if ICOMPQ = 0. If ICOMPQ = 1, on exit, PERM(1, I) records
permutations done on the I-th level of the computation tree.
GIVNUM (output) DOUBLE PRECISION array,
dimension ( LDU, 2 * NLVL ) if ICOMPQ = 1, and not
referenced if ICOMPQ = 0. If ICOMPQ = 1, on exit, for each I,
GIVNUM(1, 2 *I - 1) and GIVNUM(1, 2 *I) record the C- and S-
values of Givens rotations performed on the I-th level on
the computation tree.
C (output) DOUBLE PRECISION array,
dimension ( N ) if ICOMPQ = 1, and dimension 1 if ICOMPQ = 0.
If ICOMPQ = 1 and the I-th subproblem is not square, on exit,
C( I ) contains the C-value of a Givens rotation related to
the right null space of the I-th subproblem.
S (output) DOUBLE PRECISION array, dimension ( N ) if
ICOMPQ = 1, and dimension 1 if ICOMPQ = 0. If ICOMPQ = 1
and the I-th subproblem is not square, on exit, S( I )
contains the S-value of a Givens rotation related to
the right null space of the I-th subproblem.
WORK (workspace) DOUBLE PRECISION array, dimension
(6 * N + (SMLSIZ + 1)*(SMLSIZ + 1)).
IWORK (workspace) INTEGER array.
Dimension must be at least (7 * N).
INFO (output) INTEGER
= 0: successful exit.
< 0: if INFO = -i, the i-th argument had an illegal value.
> 0: if INFO = 1, an singular value did not converge
Further Details
===============
Based on contributions by
Ming Gu and Huan Ren, Computer Science Division, University of
California at Berkeley, USA
=====================================================================
Test the input parameters.
Parameter adjustments */
--d__;
--e;
givnum_dim1 = *ldu;
givnum_offset = 1 + givnum_dim1 * 1;
givnum -= givnum_offset;
poles_dim1 = *ldu;
poles_offset = 1 + poles_dim1 * 1;
poles -= poles_offset;
z_dim1 = *ldu;
z_offset = 1 + z_dim1 * 1;
z__ -= z_offset;
difr_dim1 = *ldu;
difr_offset = 1 + difr_dim1 * 1;
difr -= difr_offset;
difl_dim1 = *ldu;
difl_offset = 1 + difl_dim1 * 1;
difl -= difl_offset;
vt_dim1 = *ldu;
vt_offset = 1 + vt_dim1 * 1;
vt -= vt_offset;
u_dim1 = *ldu;
u_offset = 1 + u_dim1 * 1;
u -= u_offset;
--k;
--givptr;
perm_dim1 = *ldgcol;
perm_offset = 1 + perm_dim1 * 1;
perm -= perm_offset;
givcol_dim1 = *ldgcol;
givcol_offset = 1 + givcol_dim1 * 1;
givcol -= givcol_offset;
--c__;
--s;
--work;
--iwork;
/* Function Body */
*info = 0;
if (*icompq < 0 || *icompq > 1) {
*info = -1;
} else if (*smlsiz < 3) {
*info = -2;
} else if (*n < 0) {
*info = -3;
} else if (*sqre < 0 || *sqre > 1) {
*info = -4;
} else if (*ldu < *n + *sqre) {
*info = -8;
} else if (*ldgcol < *n) {
*info = -17;
}
if (*info != 0) {
i__1 = -(*info);
xerbla_("DLASDA", &i__1);
return 0;
}
m = *n + *sqre;
/* If the input matrix is too small, call DLASDQ to find the SVD. */
if (*n <= *smlsiz) {
if (*icompq == 0) {
dlasdq_("U", sqre, n, &c__0, &c__0, &c__0, &d__[1], &e[1], &vt[
vt_offset], ldu, &u[u_offset], ldu, &u[u_offset], ldu, &
work[1], info);
} else {
dlasdq_("U", sqre, n, &m, n, &c__0, &d__[1], &e[1], &vt[vt_offset]
, ldu, &u[u_offset], ldu, &u[u_offset], ldu, &work[1],
info);
}
return 0;
}
/* Book-keeping and set up the computation tree. */
inode = 1;
ndiml = inode + *n;
ndimr = ndiml + *n;
idxq = ndimr + *n;
iwk = idxq + *n;
ncc = 0;
nru = 0;
smlszp = *smlsiz + 1;
vf = 1;
vl = vf + m;
nwork1 = vl + m;
nwork2 = nwork1 + smlszp * smlszp;
dlasdt_(n, &nlvl, &nd, &iwork[inode], &iwork[ndiml], &iwork[ndimr],
smlsiz);
/* for the nodes on bottom level of the tree, solve
their subproblems by DLASDQ. */
ndb1 = (nd + 1) / 2;
i__1 = nd;
for (i__ = ndb1; i__ <= i__1; ++i__) {
/* IC : center row of each node
NL : number of rows of left subproblem
NR : number of rows of right subproblem
NLF: starting row of the left subproblem
NRF: starting row of the right subproblem */
i1 = i__ - 1;
ic = iwork[inode + i1];
nl = iwork[ndiml + i1];
nlp1 = nl + 1;
nr = iwork[ndimr + i1];
nlf = ic - nl;
nrf = ic + 1;
idxqi = idxq + nlf - 2;
vfi = vf + nlf - 1;
vli = vl + nlf - 1;
sqrei = 1;
if (*icompq == 0) {
dlaset_("A", &nlp1, &nlp1, &c_b11, &c_b12, &work[nwork1], &smlszp);
dlasdq_("U", &sqrei, &nl, &nlp1, &nru, &ncc, &d__[nlf], &e[nlf], &
work[nwork1], &smlszp, &work[nwork2], &nl, &work[nwork2],
&nl, &work[nwork2], info);
itemp = nwork1 + nl * smlszp;
dcopy_(&nlp1, &work[nwork1], &c__1, &work[vfi], &c__1);
dcopy_(&nlp1, &work[itemp], &c__1, &work[vli], &c__1);
} else {
dlaset_("A", &nl, &nl, &c_b11, &c_b12, &u_ref(nlf, 1), ldu);
dlaset_("A", &nlp1, &nlp1, &c_b11, &c_b12, &vt_ref(nlf, 1), ldu);
dlasdq_("U", &sqrei, &nl, &nlp1, &nl, &ncc, &d__[nlf], &e[nlf], &
vt_ref(nlf, 1), ldu, &u_ref(nlf, 1), ldu, &u_ref(nlf, 1),
ldu, &work[nwork1], info);
dcopy_(&nlp1, &vt_ref(nlf, 1), &c__1, &work[vfi], &c__1);
dcopy_(&nlp1, &vt_ref(nlf, nlp1), &c__1, &work[vli], &c__1);
}
if (*info != 0) {
return 0;
}
i__2 = nl;
for (j = 1; j <= i__2; ++j) {
iwork[idxqi + j] = j;
/* L10: */
}
if (i__ == nd && *sqre == 0) {
sqrei = 0;
} else {
sqrei = 1;
}
idxqi += nlp1;
vfi += nlp1;
vli += nlp1;
nrp1 = nr + sqrei;
if (*icompq == 0) {
dlaset_("A", &nrp1, &nrp1, &c_b11, &c_b12, &work[nwork1], &smlszp);
dlasdq_("U", &sqrei, &nr, &nrp1, &nru, &ncc, &d__[nrf], &e[nrf], &
work[nwork1], &smlszp, &work[nwork2], &nr, &work[nwork2],
&nr, &work[nwork2], info);
itemp = nwork1 + (nrp1 - 1) * smlszp;
dcopy_(&nrp1, &work[nwork1], &c__1, &work[vfi], &c__1);
dcopy_(&nrp1, &work[itemp], &c__1, &work[vli], &c__1);
} else {
dlaset_("A", &nr, &nr, &c_b11, &c_b12, &u_ref(nrf, 1), ldu);
dlaset_("A", &nrp1, &nrp1, &c_b11, &c_b12, &vt_ref(nrf, 1), ldu);
dlasdq_("U", &sqrei, &nr, &nrp1, &nr, &ncc, &d__[nrf], &e[nrf], &
vt_ref(nrf, 1), ldu, &u_ref(nrf, 1), ldu, &u_ref(nrf, 1),
ldu, &work[nwork1], info);
dcopy_(&nrp1, &vt_ref(nrf, 1), &c__1, &work[vfi], &c__1);
dcopy_(&nrp1, &vt_ref(nrf, nrp1), &c__1, &work[vli], &c__1);
}
if (*info != 0) {
return 0;
}
i__2 = nr;
for (j = 1; j <= i__2; ++j) {
iwork[idxqi + j] = j;
/* L20: */
}
/* L30: */
}
/* Now conquer each subproblem bottom-up. */
j = pow_ii(&c__2, &nlvl);
for (lvl = nlvl; lvl >= 1; --lvl) {
lvl2 = (lvl << 1) - 1;
/* Find the first node LF and last node LL on
the current level LVL. */
if (lvl == 1) {
lf = 1;
ll = 1;
} else {
i__1 = lvl - 1;
lf = pow_ii(&c__2, &i__1);
ll = (lf << 1) - 1;
}
i__1 = ll;
for (i__ = lf; i__ <= i__1; ++i__) {
im1 = i__ - 1;
ic = iwork[inode + im1];
nl = iwork[ndiml + im1];
nr = iwork[ndimr + im1];
nlf = ic - nl;
nrf = ic + 1;
if (i__ == ll) {
sqrei = *sqre;
} else {
sqrei = 1;
}
vfi = vf + nlf - 1;
vli = vl + nlf - 1;
idxqi = idxq + nlf - 1;
alpha = d__[ic];
beta = e[ic];
if (*icompq == 0) {
dlasd6_(icompq, &nl, &nr, &sqrei, &d__[nlf], &work[vfi], &
work[vli], &alpha, &beta, &iwork[idxqi], &perm[
perm_offset], &givptr[1], &givcol[givcol_offset],
ldgcol, &givnum[givnum_offset], ldu, &poles[
poles_offset], &difl[difl_offset], &difr[difr_offset],
&z__[z_offset], &k[1], &c__[1], &s[1], &work[nwork1],
&iwork[iwk], info);
} else {
--j;
dlasd6_(icompq, &nl, &nr, &sqrei, &d__[nlf], &work[vfi], &
work[vli], &alpha, &beta, &iwork[idxqi], &perm_ref(
nlf, lvl), &givptr[j], &givcol_ref(nlf, lvl2), ldgcol,
&givnum_ref(nlf, lvl2), ldu, &poles_ref(nlf, lvl2), &
difl_ref(nlf, lvl), &difr_ref(nlf, lvl2), &z___ref(
nlf, lvl), &k[j], &c__[j], &s[j], &work[nwork1], &
iwork[iwk], info);
}
if (*info != 0) {
return 0;
}
/* L40: */
}
/* L50: */
}
return 0;
/* End of DLASDA */
} /* dlasda_ */
int claed0_(int *qsiz, int *n, float *d__, float *e,
complex *q, int *ldq, complex *qstore, int *ldqs, float *rwork,
int *iwork, int *info)
{
/* System generated locals */
int q_dim1, q_offset, qstore_dim1, qstore_offset, i__1, i__2;
float r__1;
/* Builtin functions */
double log(double);
int pow_ii(int *, int *);
/* Local variables */
int i__, j, k, ll, iq, lgn, msd2, smm1, spm1, spm2;
float temp;
int curr, iperm;
extern int ccopy_(int *, complex *, int *,
complex *, int *);
int indxq, iwrem;
extern int scopy_(int *, float *, int *, float *,
int *);
int iqptr;
extern int claed7_(int *, int *, int *,
int *, int *, int *, float *, complex *, int *,
float *, int *, float *, int *, int *, int *,
int *, int *, float *, complex *, float *, int *,
int *);
int tlvls;
extern int clacrm_(int *, int *, complex *,
int *, float *, int *, complex *, int *, float *);
int igivcl;
extern int xerbla_(char *, int *);
extern int ilaenv_(int *, char *, char *, int *, int *,
int *, int *);
int igivnm, submat, curprb, subpbs, igivpt, curlvl, matsiz, iprmpt,
smlsiz;
extern int ssteqr_(char *, int *, float *, float *,
float *, int *, float *, int *);
/* -- LAPACK routine (version 3.2) -- */
/* Univ. of Tennessee, Univ. of California Berkeley and NAG Ltd.. */
/* November 2006 */
/* .. Scalar Arguments .. */
/* .. */
/* .. Array Arguments .. */
/* .. */
/* Purpose */
/* ======= */
/* Using the divide and conquer method, CLAED0 computes all eigenvalues */
/* of a symmetric tridiagonal matrix which is one diagonal block of */
/* those from reducing a dense or band Hermitian matrix and */
/* corresponding eigenvectors of the dense or band matrix. */
/* Arguments */
/* ========= */
/* QSIZ (input) INTEGER */
/* The dimension of the unitary matrix used to reduce */
/* the full matrix to tridiagonal form. QSIZ >= N if ICOMPQ = 1. */
/* N (input) INTEGER */
/* The dimension of the symmetric tridiagonal matrix. N >= 0. */
/* D (input/output) REAL array, dimension (N) */
/* On entry, the diagonal elements of the tridiagonal matrix. */
/* On exit, the eigenvalues in ascending order. */
/* E (input/output) REAL array, dimension (N-1) */
/* On entry, the off-diagonal elements of the tridiagonal matrix. */
/* On exit, E has been destroyed. */
/* Q (input/output) COMPLEX array, dimension (LDQ,N) */
/* On entry, Q must contain an QSIZ x N matrix whose columns */
/* unitarily orthonormal. It is a part of the unitary matrix */
/* that reduces the full dense Hermitian matrix to a */
/* (reducible) symmetric tridiagonal matrix. */
/* LDQ (input) INTEGER */
/* The leading dimension of the array Q. LDQ >= MAX(1,N). */
/* IWORK (workspace) INTEGER array, */
/* the dimension of IWORK must be at least */
/* 6 + 6*N + 5*N*lg N */
/* ( lg( N ) = smallest int k */
/* such that 2^k >= N ) */
/* RWORK (workspace) REAL array, */
/* dimension (1 + 3*N + 2*N*lg N + 3*N**2) */
/* ( lg( N ) = smallest int k */
/* such that 2^k >= N ) */
/* QSTORE (workspace) COMPLEX array, dimension (LDQS, N) */
/* Used to store parts of */
/* the eigenvector matrix when the updating matrix multiplies */
/* take place. */
/* LDQS (input) INTEGER */
/* The leading dimension of the array QSTORE. */
/* LDQS >= MAX(1,N). */
/* INFO (output) INTEGER */
/* = 0: successful exit. */
/* < 0: if INFO = -i, the i-th argument had an illegal value. */
/* > 0: The algorithm failed to compute an eigenvalue while */
/* working on the submatrix lying in rows and columns */
/* INFO/(N+1) through mod(INFO,N+1). */
/* ===================================================================== */
/* Warning: N could be as big as QSIZ! */
/* .. Parameters .. */
/* .. */
/* .. Local Scalars .. */
/* .. */
/* .. External Subroutines .. */
/* .. */
/* .. External Functions .. */
/* .. */
/* .. Intrinsic Functions .. */
/* .. */
/* .. Executable Statements .. */
/* Test the input parameters. */
/* Parameter adjustments */
--d__;
--e;
q_dim1 = *ldq;
q_offset = 1 + q_dim1;
q -= q_offset;
qstore_dim1 = *ldqs;
qstore_offset = 1 + qstore_dim1;
qstore -= qstore_offset;
--rwork;
--iwork;
/* Function Body */
*info = 0;
/* IF( ICOMPQ .LT. 0 .OR. ICOMPQ .GT. 2 ) THEN */
/* INFO = -1 */
/* ELSE IF( ( ICOMPQ .EQ. 1 ) .AND. ( QSIZ .LT. MAX( 0, N ) ) ) */
/* $ THEN */
if (*qsiz < MAX(0,*n)) {
*info = -1;
} else if (*n < 0) {
*info = -2;
} else if (*ldq < MAX(1,*n)) {
*info = -6;
} else if (*ldqs < MAX(1,*n)) {
*info = -8;
}
if (*info != 0) {
i__1 = -(*info);
xerbla_("CLAED0", &i__1);
return 0;
}
/* Quick return if possible */
if (*n == 0) {
return 0;
}
smlsiz = ilaenv_(&c__9, "CLAED0", " ", &c__0, &c__0, &c__0, &c__0);
/* Determine the size and placement of the submatrices, and save in */
/* the leading elements of IWORK. */
iwork[1] = *n;
subpbs = 1;
tlvls = 0;
L10:
if (iwork[subpbs] > smlsiz) {
for (j = subpbs; j >= 1; --j) {
iwork[j * 2] = (iwork[j] + 1) / 2;
iwork[(j << 1) - 1] = iwork[j] / 2;
/* L20: */
}
++tlvls;
subpbs <<= 1;
goto L10;
}
i__1 = subpbs;
for (j = 2; j <= i__1; ++j) {
iwork[j] += iwork[j - 1];
/* L30: */
}
/* Divide the matrix into SUBPBS submatrices of size at most SMLSIZ+1 */
/* using rank-1 modifications (cuts). */
spm1 = subpbs - 1;
i__1 = spm1;
for (i__ = 1; i__ <= i__1; ++i__) {
submat = iwork[i__] + 1;
smm1 = submat - 1;
d__[smm1] -= (r__1 = e[smm1], ABS(r__1));
d__[submat] -= (r__1 = e[smm1], ABS(r__1));
/* L40: */
}
indxq = (*n << 2) + 3;
/* Set up workspaces for eigenvalues only/accumulate new vectors */
/* routine */
temp = log((float) (*n)) / log(2.f);
lgn = (int) temp;
if (pow_ii(&c__2, &lgn) < *n) {
++lgn;
}
if (pow_ii(&c__2, &lgn) < *n) {
++lgn;
}
iprmpt = indxq + *n + 1;
iperm = iprmpt + *n * lgn;
iqptr = iperm + *n * lgn;
igivpt = iqptr + *n + 2;
igivcl = igivpt + *n * lgn;
igivnm = 1;
iq = igivnm + (*n << 1) * lgn;
/* Computing 2nd power */
i__1 = *n;
iwrem = iq + i__1 * i__1 + 1;
/* Initialize pointers */
i__1 = subpbs;
for (i__ = 0; i__ <= i__1; ++i__) {
iwork[iprmpt + i__] = 1;
iwork[igivpt + i__] = 1;
/* L50: */
}
iwork[iqptr] = 1;
/* Solve each submatrix eigenproblem at the bottom of the divide and */
/* conquer tree. */
curr = 0;
i__1 = spm1;
for (i__ = 0; i__ <= i__1; ++i__) {
if (i__ == 0) {
submat = 1;
matsiz = iwork[1];
} else {
submat = iwork[i__] + 1;
matsiz = iwork[i__ + 1] - iwork[i__];
}
ll = iq - 1 + iwork[iqptr + curr];
ssteqr_("I", &matsiz, &d__[submat], &e[submat], &rwork[ll], &matsiz, &
rwork[1], info);
clacrm_(qsiz, &matsiz, &q[submat * q_dim1 + 1], ldq, &rwork[ll], &
matsiz, &qstore[submat * qstore_dim1 + 1], ldqs, &rwork[iwrem]
);
/* Computing 2nd power */
i__2 = matsiz;
iwork[iqptr + curr + 1] = iwork[iqptr + curr] + i__2 * i__2;
++curr;
if (*info > 0) {
*info = submat * (*n + 1) + submat + matsiz - 1;
return 0;
}
k = 1;
i__2 = iwork[i__ + 1];
for (j = submat; j <= i__2; ++j) {
iwork[indxq + j] = k;
++k;
/* L60: */
}
/* L70: */
}
/* Successively merge eigensystems of adjacent submatrices */
/* into eigensystem for the corresponding larger matrix. */
/* while ( SUBPBS > 1 ) */
curlvl = 1;
L80:
if (subpbs > 1) {
spm2 = subpbs - 2;
i__1 = spm2;
for (i__ = 0; i__ <= i__1; i__ += 2) {
if (i__ == 0) {
submat = 1;
matsiz = iwork[2];
msd2 = iwork[1];
curprb = 0;
} else {
submat = iwork[i__] + 1;
matsiz = iwork[i__ + 2] - iwork[i__];
msd2 = matsiz / 2;
++curprb;
}
/* Merge lower order eigensystems (of size MSD2 and MATSIZ - MSD2) */
/* into an eigensystem of size MATSIZ. CLAED7 handles the case */
/* when the eigenvectors of a full or band Hermitian matrix (which */
/* was reduced to tridiagonal form) are desired. */
/* I am free to use Q as a valuable working space until Loop 150. */
claed7_(&matsiz, &msd2, qsiz, &tlvls, &curlvl, &curprb, &d__[
submat], &qstore[submat * qstore_dim1 + 1], ldqs, &e[
submat + msd2 - 1], &iwork[indxq + submat], &rwork[iq], &
iwork[iqptr], &iwork[iprmpt], &iwork[iperm], &iwork[
igivpt], &iwork[igivcl], &rwork[igivnm], &q[submat *
q_dim1 + 1], &rwork[iwrem], &iwork[subpbs + 1], info);
if (*info > 0) {
*info = submat * (*n + 1) + submat + matsiz - 1;
return 0;
}
iwork[i__ / 2 + 1] = iwork[i__ + 2];
/* L90: */
}
subpbs /= 2;
++curlvl;
goto L80;
}
/* end while */
/* Re-merge the eigenvalues/vectors which were deflated at the final */
/* merge step. */
i__1 = *n;
for (i__ = 1; i__ <= i__1; ++i__) {
j = iwork[indxq + i__];
rwork[i__] = d__[j];
ccopy_(qsiz, &qstore[j * qstore_dim1 + 1], &c__1, &q[i__ * q_dim1 + 1]
, &c__1);
/* L100: */
}
scopy_(n, &rwork[1], &c__1, &d__[1], &c__1);
return 0;
/* End of CLAED0 */
} /* claed0_ */
/* DECK MPBLAS */
/* Subroutine */ int mpblas_(integer *i1)
{
/* System generated locals */
integer i__1, i__2;
/* Local variables */
extern integer i1mach_(integer *);
static integer mpbexp;
extern /* Subroutine */ int xermsg_(char *, char *, char *, integer *,
integer *, ftnlen, ftnlen, ftnlen);
/* ***BEGIN PROLOGUE MPBLAS */
/* ***SUBSIDIARY */
/* ***PURPOSE Subsidiary to DQDOTA and DQDOTI */
/* ***LIBRARY SLATEC */
/* ***TYPE ALL (MPBLAS-A) */
/* ***AUTHOR (UNKNOWN) */
/* ***DESCRIPTION */
/* This subroutine is called to set up Brent's 'mp' package */
/* for use by the extended precision inner products from the BLAS. */
/* In the SLATEC library we require the Extended Precision MP number */
/* to have a mantissa twice as long as Double Precision numbers. */
/* The calculation of MPT (and MPMXR which is the actual array size) */
/* in this routine will give 2x (or slightly more) on the machine */
/* that we are running on. The INTEGER array size of 30 was chosen */
/* to be slightly longer than the longest INTEGER array needed on */
/* any machine that we are currently aware of. */
/* ***SEE ALSO DQDOTA, DQDOTI */
/* ***REFERENCES R. P. Brent, A Fortran multiple-precision arithmetic */
/* package, ACM Transactions on Mathematical Software 4, */
/* 1 (March 1978), pp. 57-70. */
/* R. P. Brent, MP, a Fortran multiple-precision arithmetic */
/* package, Algorithm 524, ACM Transactions on Mathema- */
/* tical Software 4, 1 (March 1978), pp. 71-81. */
/* ***ROUTINES CALLED I1MACH, XERMSG */
/* ***COMMON BLOCKS MPCOM */
/* ***REVISION HISTORY (YYMMDD) */
/* 791001 DATE WRITTEN */
/* 890531 Changed all specific intrinsics to generic. (WRB) */
/* 890531 REVISION DATE from Version 3.2 */
/* 891214 Prologue converted to Version 4.0 format. (BAB) */
/* 900402 Added TYPE section. (WRB) */
/* 920501 Reformatted the REFERENCES section. (WRB) */
/* 930124 Increased Array size in MPCON for SUN -r8, and calculate */
/* size for Quad Precision for 2x DP. (RWC) */
/* ***END PROLOGUE MPBLAS */
/* ***FIRST EXECUTABLE STATEMENT MPBLAS */
*i1 = 1;
/* For full extended precision accuracy, MPB should be as large as */
/* possible, subject to the restrictions in Brent's paper. */
/* Statements below are for an integer wordlength of 48, 36, 32, */
/* 24, 18, and 16. Pick one, or generate a new one. */
/* 48 MPB = 4194304 */
/* 36 MPB = 65536 */
/* 32 MPB = 16384 */
/* 24 MPB = 1024 */
/* 18 MPB = 128 */
/* 16 MPB = 64 */
mpbexp = i1mach_(&c__8) / 2 - 2;
mpcom_1.mpb = pow_ii(&c__2, &mpbexp);
/* Set up remaining parameters */
/* UNIT FOR ERROR MESSAGES */
mpcom_1.mplun = i1mach_(&c__4);
/* NUMBER OF MP DIGITS */
mpcom_1.mpt = ((i1mach_(&c__14) << 1) + mpbexp - 1) / mpbexp;
/* DIMENSION OF R */
mpcom_1.mpmxr = mpcom_1.mpt + 4;
if (mpcom_1.mpmxr > 30) {
xermsg_("SLATEC", "MPBLAS", "Array space not sufficient for Quad Pre"
"cision 2x Double Precision, Proceeding.", &c__1, &c__1, (
ftnlen)6, (ftnlen)6, (ftnlen)78);
mpcom_1.mpt = 26;
mpcom_1.mpmxr = 30;
}
/* EXPONENT RANGE */
/* Computing MIN */
i__1 = 32767, i__2 = i1mach_(&c__9) / 4 - 1;
mpcom_1.mpm = min(i__1,i__2);
return 0;
} /* mpblas_ */
int claed7_(int *n, int *cutpnt, int *qsiz,
int *tlvls, int *curlvl, int *curpbm, float *d__, complex *
q, int *ldq, float *rho, int *indxq, float *qstore, int *
qptr, int *prmptr, int *perm, int *givptr, int *
givcol, float *givnum, complex *work, float *rwork, int *iwork,
int *info)
{
/* System generated locals */
int q_dim1, q_offset, i__1, i__2;
/* Builtin functions */
int pow_ii(int *, int *);
/* Local variables */
int i__, k, n1, n2, iq, iw, iz, ptr, indx, curr, indxc, indxp;
extern int claed8_(int *, int *, int *,
complex *, int *, float *, float *, int *, float *, float *,
complex *, int *, float *, int *, int *, int *,
int *, int *, int *, float *, int *), slaed9_(
int *, int *, int *, int *, float *, float *,
int *, float *, float *, float *, float *, int *, int *),
slaeda_(int *, int *, int *, int *, int *,
int *, int *, int *, float *, float *, int *, float *
, float *, int *);
int idlmda;
extern int clacrm_(int *, int *, complex *,
int *, float *, int *, complex *, int *, float *),
xerbla_(char *, int *), slamrg_(int *, int *,
float *, int *, int *, int *);
int coltyp;
/* -- LAPACK routine (version 3.2) -- */
/* Univ. of Tennessee, Univ. of California Berkeley and NAG Ltd.. */
/* November 2006 */
/* .. Scalar Arguments .. */
/* .. */
/* .. Array Arguments .. */
/* .. */
/* Purpose */
/* ======= */
/* CLAED7 computes the updated eigensystem of a diagonal */
/* matrix after modification by a rank-one symmetric matrix. This */
/* routine is used only for the eigenproblem which requires all */
/* eigenvalues and optionally eigenvectors of a dense or banded */
/* Hermitian matrix that has been reduced to tridiagonal form. */
/* T = Q(in) ( D(in) + RHO * Z*Z' ) Q'(in) = Q(out) * D(out) * Q'(out) */
/* where Z = Q'u, u is a vector of length N with ones in the */
/* CUTPNT and CUTPNT + 1 th elements and zeros elsewhere. */
/* The eigenvectors of the original matrix are stored in Q, and the */
/* eigenvalues are in D. The algorithm consists of three stages: */
/* The first stage consists of deflating the size of the problem */
/* when there are multiple eigenvalues or if there is a zero in */
/* the Z vector. For each such occurence the dimension of the */
/* secular equation problem is reduced by one. This stage is */
/* performed by the routine SLAED2. */
/* The second stage consists of calculating the updated */
/* eigenvalues. This is done by finding the roots of the secular */
/* equation via the routine SLAED4 (as called by SLAED3). */
/* This routine also calculates the eigenvectors of the current */
/* problem. */
/* The final stage consists of computing the updated eigenvectors */
/* directly using the updated eigenvalues. The eigenvectors for */
/* the current problem are multiplied with the eigenvectors from */
/* the overall problem. */
/* Arguments */
/* ========= */
/* N (input) INTEGER */
/* The dimension of the symmetric tridiagonal matrix. N >= 0. */
/* CUTPNT (input) INTEGER */
/* Contains the location of the last eigenvalue in the leading */
/* sub-matrix. MIN(1,N) <= CUTPNT <= N. */
/* QSIZ (input) INTEGER */
/* The dimension of the unitary matrix used to reduce */
/* the full matrix to tridiagonal form. QSIZ >= N. */
/* TLVLS (input) INTEGER */
/* The total number of merging levels in the overall divide and */
/* conquer tree. */
/* CURLVL (input) INTEGER */
/* The current level in the overall merge routine, */
/* 0 <= curlvl <= tlvls. */
/* CURPBM (input) INTEGER */
/* The current problem in the current level in the overall */
/* merge routine (counting from upper left to lower right). */
/* D (input/output) REAL array, dimension (N) */
/* On entry, the eigenvalues of the rank-1-perturbed matrix. */
/* On exit, the eigenvalues of the repaired matrix. */
/* Q (input/output) COMPLEX array, dimension (LDQ,N) */
/* On entry, the eigenvectors of the rank-1-perturbed matrix. */
/* On exit, the eigenvectors of the repaired tridiagonal matrix. */
/* LDQ (input) INTEGER */
/* The leading dimension of the array Q. LDQ >= MAX(1,N). */
/* RHO (input) REAL */
/* Contains the subdiagonal element used to create the rank-1 */
/* modification. */
/* INDXQ (output) INTEGER array, dimension (N) */
/* This contains the permutation which will reintegrate the */
/* subproblem just solved back into sorted order, */
/* ie. D( INDXQ( I = 1, N ) ) will be in ascending order. */
/* IWORK (workspace) INTEGER array, dimension (4*N) */
/* RWORK (workspace) REAL array, */
/* dimension (3*N+2*QSIZ*N) */
/* WORK (workspace) COMPLEX array, dimension (QSIZ*N) */
/* QSTORE (input/output) REAL array, dimension (N**2+1) */
/* Stores eigenvectors of submatrices encountered during */
/* divide and conquer, packed together. QPTR points to */
/* beginning of the submatrices. */
/* QPTR (input/output) INTEGER array, dimension (N+2) */
/* List of indices pointing to beginning of submatrices stored */
/* in QSTORE. The submatrices are numbered starting at the */
/* bottom left of the divide and conquer tree, from left to */
/* right and bottom to top. */
/* PRMPTR (input) INTEGER array, dimension (N lg N) */
/* Contains a list of pointers which indicate where in PERM a */
/* level's permutation is stored. PRMPTR(i+1) - PRMPTR(i) */
/* indicates the size of the permutation and also the size of */
/* the full, non-deflated problem. */
/* PERM (input) INTEGER array, dimension (N lg N) */
/* Contains the permutations (from deflation and sorting) to be */
/* applied to each eigenblock. */
/* GIVPTR (input) INTEGER array, dimension (N lg N) */
/* Contains a list of pointers which indicate where in GIVCOL a */
/* level's Givens rotations are stored. GIVPTR(i+1) - GIVPTR(i) */
/* indicates the number of Givens rotations. */
/* GIVCOL (input) INTEGER array, dimension (2, N lg N) */
/* Each pair of numbers indicates a pair of columns to take place */
/* in a Givens rotation. */
/* GIVNUM (input) REAL array, dimension (2, N lg N) */
/* Each number indicates the S value to be used in the */
/* corresponding Givens rotation. */
/* INFO (output) INTEGER */
/* = 0: successful exit. */
/* < 0: if INFO = -i, the i-th argument had an illegal value. */
/* > 0: if INFO = 1, an eigenvalue did not converge */
/* ===================================================================== */
/* .. Local Scalars .. */
/* .. */
/* .. External Subroutines .. */
/* .. */
/* .. Intrinsic Functions .. */
/* .. */
/* .. Executable Statements .. */
/* Test the input parameters. */
/* Parameter adjustments */
--d__;
q_dim1 = *ldq;
q_offset = 1 + q_dim1;
q -= q_offset;
--indxq;
--qstore;
--qptr;
--prmptr;
--perm;
--givptr;
givcol -= 3;
givnum -= 3;
--work;
--rwork;
--iwork;
/* Function Body */
*info = 0;
/* IF( ICOMPQ.LT.0 .OR. ICOMPQ.GT.1 ) THEN */
/* INFO = -1 */
/* ELSE IF( N.LT.0 ) THEN */
if (*n < 0) {
*info = -1;
} else if (MIN(1,*n) > *cutpnt || *n < *cutpnt) {
*info = -2;
} else if (*qsiz < *n) {
*info = -3;
} else if (*ldq < MAX(1,*n)) {
*info = -9;
}
if (*info != 0) {
i__1 = -(*info);
xerbla_("CLAED7", &i__1);
return 0;
}
/* Quick return if possible */
if (*n == 0) {
return 0;
}
/* The following values are for bookkeeping purposes only. They are */
/* int pointers which indicate the portion of the workspace */
/* used by a particular array in SLAED2 and SLAED3. */
iz = 1;
idlmda = iz + *n;
iw = idlmda + *n;
iq = iw + *n;
indx = 1;
indxc = indx + *n;
coltyp = indxc + *n;
indxp = coltyp + *n;
/* Form the z-vector which consists of the last row of Q_1 and the */
/* first row of Q_2. */
ptr = pow_ii(&c__2, tlvls) + 1;
i__1 = *curlvl - 1;
for (i__ = 1; i__ <= i__1; ++i__) {
i__2 = *tlvls - i__;
ptr += pow_ii(&c__2, &i__2);
/* L10: */
}
curr = ptr + *curpbm;
slaeda_(n, tlvls, curlvl, curpbm, &prmptr[1], &perm[1], &givptr[1], &
givcol[3], &givnum[3], &qstore[1], &qptr[1], &rwork[iz], &rwork[
iz + *n], info);
/* When solving the final problem, we no longer need the stored data, */
/* so we will overwrite the data from this level onto the previously */
/* used storage space. */
if (*curlvl == *tlvls) {
qptr[curr] = 1;
prmptr[curr] = 1;
givptr[curr] = 1;
}
/* Sort and Deflate eigenvalues. */
claed8_(&k, n, qsiz, &q[q_offset], ldq, &d__[1], rho, cutpnt, &rwork[iz],
&rwork[idlmda], &work[1], qsiz, &rwork[iw], &iwork[indxp], &iwork[
indx], &indxq[1], &perm[prmptr[curr]], &givptr[curr + 1], &givcol[
(givptr[curr] << 1) + 1], &givnum[(givptr[curr] << 1) + 1], info);
prmptr[curr + 1] = prmptr[curr] + *n;
givptr[curr + 1] += givptr[curr];
/* Solve Secular Equation. */
if (k != 0) {
slaed9_(&k, &c__1, &k, n, &d__[1], &rwork[iq], &k, rho, &rwork[idlmda]
, &rwork[iw], &qstore[qptr[curr]], &k, info);
clacrm_(qsiz, &k, &work[1], qsiz, &qstore[qptr[curr]], &k, &q[
q_offset], ldq, &rwork[iq]);
/* Computing 2nd power */
i__1 = k;
qptr[curr + 1] = qptr[curr] + i__1 * i__1;
if (*info != 0) {
return 0;
}
/* Prepare the INDXQ sorting premutation. */
n1 = k;
n2 = *n - k;
slamrg_(&n1, &n2, &d__[1], &c__1, &c_n1, &indxq[1]);
} else {
qptr[curr + 1] = qptr[curr];
i__1 = *n;
for (i__ = 1; i__ <= i__1; ++i__) {
indxq[i__] = i__;
/* L20: */
}
}
return 0;
/* End of CLAED7 */
} /* claed7_ */
/* Subroutine */ int initsv_(integer *indeps)
{
/* Initialized data */
static doublereal rvdw[53] = { 1.08,1.,1.8,999.,999.,1.53,1.48,1.36,1.3,
999.,2.3,999.,2.05,2.1,1.75,1.7,1.65,999.,2.8,2.75,999.,999.,999.,
999.,999.,999.,999.,999.,999.,999.,999.,999.,999.,999.,1.8,999.,
999.,999.,999.,999.,999.,999.,999.,999.,999.,999.,999.,999.,999.,
999.,999.,999.,2.05 };
/* System generated locals */
integer i__1, i__2;
doublereal d__1;
/* Builtin functions */
double sqrt(doublereal);
integer s_wsle(cilist *), do_lio(integer *, integer *, char *, ftnlen),
e_wsle(void);
/* Subroutine */ int s_stop(char *, ftnlen);
integer i_indx(char *, char *, ftnlen, ftnlen), i_dnnt(doublereal *);
double log(doublereal);
integer pow_ii(integer *, integer *);
/* Local variables */
static integer i__, n;
static doublereal x;
static integer i4;
static doublereal x0, z3, z4;
#define iw ((integer *)&chanel_1 + 5)
static integer iat;
static doublereal epsi, avdw;
extern doublereal reada_(char *, integer *, ftnlen);
static doublereal delsc, disex;
#define dirsm ((doublereal *)&solv_1 + 1325)
static doublereal rsolv;
static integer indels, indise;
extern /* Subroutine */ int dvfill_(integer *, doublereal *);
#define dirsmh ((doublereal *)&solv_1 + 4571)
static integer maxnps, inrsol;
static doublereal usevdw[53];
/* Fortran I/O blocks */
static cilist io___10 = { 0, 0, 0, 0, 0 };
static cilist io___15 = { 0, 0, 0, 0, 0 };
/* COMDECK SIZES */
/* *********************************************************************** */
/* THIS FILE CONTAINS ALL THE ARRAY SIZES FOR USE IN MOPAC. */
/* THERE ARE ONLY 5 PARAMETERS THAT THE PROGRAMMER NEED SET: */
/* MAXHEV = MAXIMUM NUMBER OF HEAVY ATOMS (HEAVY: NON-HYDROGEN ATOMS) */
/* MAXLIT = MAXIMUM NUMBER OF HYDROGEN ATOMS. */
/* MAXTIM = DEFAULT TIME FOR A JOB. (SECONDS) */
/* MAXDMP = DEFAULT TIME FOR AUTOMATIC RESTART FILE GENERATION (SECS) */
/* ISYBYL = 1 IF MOPAC IS TO BE USED IN THE SYBYL PACKAGE, =0 OTHERWISE */
/* SEE ALSO NMECI, NPULAY AND MESP AT THE END OF THIS FILE */
/* *********************************************************************** */
/* THE FOLLOWING CODE DOES NOT NEED TO BE ALTERED BY THE PROGRAMMER */
/* *********************************************************************** */
/* ALL OTHER PARAMETERS ARE DERIVED FUNCTIONS OF THESE TWO PARAMETERS */
/* NAME DEFINITION */
/* NUMATM MAXIMUM NUMBER OF ATOMS ALLOWED. */
/* MAXORB MAXIMUM NUMBER OF ORBITALS ALLOWED. */
/* MAXPAR MAXIMUM NUMBER OF PARAMETERS FOR OPTIMISATION. */
/* N2ELEC MAXIMUM NUMBER OF TWO ELECTRON INTEGRALS ALLOWED. */
/* MPACK AREA OF LOWER HALF TRIANGLE OF DENSITY MATRIX. */
/* MORB2 SQUARE OF THE MAXIMUM NUMBER OF ORBITALS ALLOWED. */
/* MAXHES AREA OF HESSIAN MATRIX */
/* MAXALL LARGER THAN MAXORB OR MAXPAR. */
/* *********************************************************************** */
/* *********************************************************************** */
/* DECK MOPAC */
for (i__ = 1; i__ <= 53; ++i__) {
/* L10: */
usevdw[i__ - 1] = rvdw[i__ - 1];
}
epsi = reada_(keywrd_1.keywrd, indeps, (ftnlen)241);
solv_1.fepsi = (epsi - 1.) / (epsi + .5);
solvps_1.nps = 0;
*iw = 6;
solv_1.nden = molkst_1.norbs * 3 - (molkst_1.numat << 1);
maxnps = sqrt(324000.25099999999f) - solv_1.nden - .5f;
maxnps = min(maxnps,400);
/* WRITE(IW,*) 'MAXIMUM NUMBER OF SEGMENTS ALLOWED:',MAXNPS */
if (solv_1.nden * (solv_1.nden + 1) / 2 > 162000) {
io___10.ciunit = *iw;
s_wsle(&io___10);
do_lio(&c__9, &c__1, "PARAMETER LENABC IS TOO SMALL FOR THIS SYSTEM",
(ftnlen)45);
e_wsle();
s_stop("PARAMETER LENABC IS TOO SMALL FOR THIS SYSTEM", (ftnlen)45);
}
rsolv = 1.;
inrsol = i_indx(keywrd_1.keywrd, "RSOLV=", (ftnlen)241, (ftnlen)6);
if (inrsol != 0) {
rsolv = reada_(keywrd_1.keywrd, &inrsol, (ftnlen)241);
}
if (rsolv < 0.f) {
s_stop(" RSOLV MUST NOT BE NEGATIVE", (ftnlen)27);
}
delsc = rsolv;
indels = i_indx(keywrd_1.keywrd, "DELSC=", (ftnlen)241, (ftnlen)6);
if (indels != 0) {
delsc = reada_(keywrd_1.keywrd, &indels, (ftnlen)241);
}
if (delsc < .1) {
io___15.ciunit = *iw;
s_wsle(&io___15);
do_lio(&c__9, &c__1, " DELSC TOO SMALL: SET TO 0.1", (ftnlen)28);
e_wsle();
}
if (delsc > rsolv + .5) {
s_stop(" DELSC UNREASONABLY LARGE", (ftnlen)25);
}
solv_1.rds = max(delsc,.1);
disex = 2.;
indise = i_indx(keywrd_1.keywrd, "DISEX=", (ftnlen)241, (ftnlen)6);
if (indise != 0) {
disex = reada_(keywrd_1.keywrd, &indise, (ftnlen)241);
}
i__1 = molkst_1.numat;
for (i__ = 1; i__ <= i__1; ++i__) {
iat = molkst_1.nat[i__ - 1];
if (iat > 53) {
s_stop("MISSING VAN DER WAALS RADIUS", (ftnlen)28);
} else {
avdw = usevdw[iat - 1];
if (avdw > 10.) {
s_stop("MISSING VAN DER WAALS RADIUS", (ftnlen)28);
}
}
solv_1.srad[i__ - 1] = avdw + rsolv;
/* L20: */
}
solv_1.nspa = 60;
if (i_indx(keywrd_1.keywrd, "NSPA=", (ftnlen)241, (ftnlen)5) != 0) {
i__1 = i_indx(keywrd_1.keywrd, "NSPA", (ftnlen)241, (ftnlen)4);
d__1 = reada_(keywrd_1.keywrd, &i__1, (ftnlen)241);
solv_1.nspa = i_dnnt(&d__1);
}
x0 = log(solv_1.nspa * .1 - .199999);
z3 = log(3.);
z4 = log(4.);
i4 = (integer) (x0 / z4);
solvps_1.nps2 = 0;
i__1 = i4;
for (i__ = 0; i__ <= i__1; ++i__) {
x = x0 - i__ * z4;
i__2 = (integer) (x / z3);
n = pow_ii(&c__3, &i__2) * pow_ii(&c__4, &i__);
/* L7: */
if (n > solvps_1.nps2) {
solvps_1.nps2 = n;
}
}
solvps_1.nps = solvps_1.nps2 / 3;
if (solvps_1.nps2 % 3 != 0) {
solvps_1.nps = solvps_1.nps2 / 4;
}
solvps_1.nps2 = solvps_1.nps2 * 10 + 2;
/* Computing MAX */
i__1 = 12, i__2 = solvps_1.nps * 10 + 2;
solvps_1.nps = max(i__1,i__2);
dvfill_(&solvps_1.nps2, dirsm);
dvfill_(&solvps_1.nps, dirsmh);
solvps_1.nps = -solvps_1.nps;
/* Computing 2nd power */
d__1 = (rsolv + 1.5 - solv_1.rds) * 4 * disex;
solv_1.disex2 = d__1 * d__1 / solv_1.nspa;
dvfill_(&c__1082, dirvec_1.dirvec);
return 0;
} /* initsv_ */
/* ----------------------------------------------------------------------| */
/* Subroutine */ int zgpadm_(integer *ideg, integer *m, doublereal *t,
doublecomplex *h__, integer *ldh, doublecomplex *wsp, integer *lwsp,
integer *ipiv, integer *iexph, integer *ns, integer *iflag)
{
/* System generated locals */
integer h_dim1, h_offset, i__1, i__2, i__3, i__4;
doublereal d__1, d__2;
doublecomplex z__1, z__2;
/* Builtin functions */
/* Subroutine */ int s_stop(char *, ftnlen);
double z_abs(doublecomplex *), log(doublereal);
integer pow_ii(integer *, integer *);
/* Local variables */
static integer i__, j, k;
static doublecomplex cp, cq;
static integer ip, mm, iq, ih2, iodd, iget, iput, icoef;
static doublecomplex scale;
static integer ifree, iused;
extern /* Subroutine */ int zgemm_(char *, char *, integer *, integer *,
integer *, doublecomplex *, doublecomplex *, integer *,
doublecomplex *, integer *, doublecomplex *, doublecomplex *,
integer *, ftnlen, ftnlen);
static doublereal hnorm;
extern /* Subroutine */ int zgesv_(integer *, integer *, doublecomplex *,
integer *, integer *, doublecomplex *, integer *, integer *);
static doublecomplex scale2;
extern /* Subroutine */ int zaxpy_(integer *, doublecomplex *,
doublecomplex *, integer *, doublecomplex *, integer *), zdscal_(
integer *, doublereal *, doublecomplex *, integer *);
/* -----Purpose----------------------------------------------------------| */
/* Computes exp(t*H), the matrix exponential of a general complex */
/* matrix in full, using the irreducible rational Pade approximation */
/* to the exponential exp(z) = r(z) = (+/-)( I + 2*(q(z)/p(z)) ), */
/* combined with scaling-and-squaring. */
/* -----Arguments--------------------------------------------------------| */
/* ideg : (input) the degre of the diagonal Pade to be used. */
/* a value of 6 is generally satisfactory. */
/* m : (input) order of H. */
/* H(ldh,m) : (input) argument matrix. */
/* t : (input) time-scale (can be < 0). */
/* wsp(lwsp) : (workspace/output) lwsp .ge. 4*m*m+ideg+1. */
/* ipiv(m) : (workspace) */
/* >>>> iexph : (output) number such that wsp(iexph) points to exp(tH) */
/* i.e., exp(tH) is located at wsp(iexph ... iexph+m*m-1) */
/* ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ */
/* NOTE: if the routine was called with wsp(iptr), */
/* then exp(tH) will start at wsp(iptr+iexph-1). */
/* ns : (output) number of scaling-squaring used. */
/* iflag : (output) exit flag. */
/* 0 - no problem */
/* <0 - problem */
/* ----------------------------------------------------------------------| */
/* Roger B. Sidje ([email protected]) */
/* EXPOKIT: Software Package for Computing Matrix Exponentials. */
/* ACM - Transactions On Mathematical Software, 24(1):130-156, 1998 */
/* ----------------------------------------------------------------------| */
/* --- check restrictions on input parameters ... */
/* Parameter adjustments */
--ipiv;
h_dim1 = *ldh;
h_offset = 1 + h_dim1;
h__ -= h_offset;
--wsp;
/* Function Body */
mm = *m * *m;
*iflag = 0;
if (*ldh < *m) {
*iflag = -1;
}
if (*lwsp < (mm << 2) + *ideg + 1) {
*iflag = -2;
}
if (*iflag != 0) {
s_stop("bad sizes (in input of ZGPADM)", (ftnlen)30);
}
/* --- initialise pointers ... */
icoef = 1;
ih2 = icoef + (*ideg + 1);
ip = ih2 + mm;
iq = ip + mm;
ifree = iq + mm;
/* --- scaling: seek ns such that ||t*H/2^ns|| < 1/2; */
/* and set scale = t/2^ns ... */
i__1 = *m;
for (i__ = 1; i__ <= i__1; ++i__) {
i__2 = i__;
wsp[i__2].r = 0., wsp[i__2].i = 0.;
}
i__1 = *m;
for (j = 1; j <= i__1; ++j) {
i__2 = *m;
for (i__ = 1; i__ <= i__2; ++i__) {
i__3 = i__;
i__4 = i__;
d__1 = z_abs(&h__[i__ + j * h_dim1]);
z__1.r = wsp[i__4].r + d__1, z__1.i = wsp[i__4].i;
wsp[i__3].r = z__1.r, wsp[i__3].i = z__1.i;
}
}
hnorm = 0.;
i__1 = *m;
for (i__ = 1; i__ <= i__1; ++i__) {
/* Computing MAX */
i__2 = i__;
d__1 = hnorm, d__2 = wsp[i__2].r;
hnorm = max(d__1,d__2);
}
hnorm = (d__1 = *t * hnorm, abs(d__1));
if (hnorm == 0.) {
s_stop("Error - null H in input of ZGPADM.", (ftnlen)34);
}
/* Computing MAX */
i__1 = 0, i__2 = (integer) (log(hnorm) / log(2.)) + 2;
*ns = max(i__1,i__2);
d__1 = *t / (doublereal) pow_ii(&c__2, ns);
z__1.r = d__1, z__1.i = 0.;
scale.r = z__1.r, scale.i = z__1.i;
z__1.r = scale.r * scale.r - scale.i * scale.i, z__1.i = scale.r *
scale.i + scale.i * scale.r;
scale2.r = z__1.r, scale2.i = z__1.i;
/* --- compute Pade coefficients ... */
i__ = *ideg + 1;
j = (*ideg << 1) + 1;
i__1 = icoef;
wsp[i__1].r = 1., wsp[i__1].i = 0.;
i__1 = *ideg;
for (k = 1; k <= i__1; ++k) {
i__2 = icoef + k;
i__3 = icoef + k - 1;
d__1 = (doublereal) (i__ - k);
z__2.r = d__1 * wsp[i__3].r, z__2.i = d__1 * wsp[i__3].i;
d__2 = (doublereal) (k * (j - k));
z__1.r = z__2.r / d__2, z__1.i = z__2.i / d__2;
wsp[i__2].r = z__1.r, wsp[i__2].i = z__1.i;
}
/* --- H2 = scale2*H*H ... */
zgemm_("n", "n", m, m, m, &scale2, &h__[h_offset], ldh, &h__[h_offset],
ldh, &c_b1, &wsp[ih2], m, (ftnlen)1, (ftnlen)1);
/* --- initialise p (numerator) and q (denominator) ... */
i__1 = icoef + *ideg - 1;
cp.r = wsp[i__1].r, cp.i = wsp[i__1].i;
i__1 = icoef + *ideg;
cq.r = wsp[i__1].r, cq.i = wsp[i__1].i;
i__1 = *m;
for (j = 1; j <= i__1; ++j) {
i__2 = *m;
for (i__ = 1; i__ <= i__2; ++i__) {
i__3 = ip + (j - 1) * *m + i__ - 1;
wsp[i__3].r = 0., wsp[i__3].i = 0.;
i__3 = iq + (j - 1) * *m + i__ - 1;
wsp[i__3].r = 0., wsp[i__3].i = 0.;
}
i__2 = ip + (j - 1) * (*m + 1);
wsp[i__2].r = cp.r, wsp[i__2].i = cp.i;
i__2 = iq + (j - 1) * (*m + 1);
wsp[i__2].r = cq.r, wsp[i__2].i = cq.i;
}
/* --- Apply Horner rule ... */
iodd = 1;
k = *ideg - 1;
L100:
iused = iodd * iq + (1 - iodd) * ip;
zgemm_("n", "n", m, m, m, &c_b2, &wsp[iused], m, &wsp[ih2], m, &c_b1, &
wsp[ifree], m, (ftnlen)1, (ftnlen)1);
i__1 = *m;
for (j = 1; j <= i__1; ++j) {
i__2 = ifree + (j - 1) * (*m + 1);
i__3 = ifree + (j - 1) * (*m + 1);
i__4 = icoef + k - 1;
z__1.r = wsp[i__3].r + wsp[i__4].r, z__1.i = wsp[i__3].i + wsp[i__4]
.i;
wsp[i__2].r = z__1.r, wsp[i__2].i = z__1.i;
}
ip = (1 - iodd) * ifree + iodd * ip;
iq = iodd * ifree + (1 - iodd) * iq;
ifree = iused;
iodd = 1 - iodd;
--k;
if (k > 0) {
goto L100;
}
/* --- Obtain (+/-)(I + 2*(p\q)) ... */
if (iodd != 0) {
zgemm_("n", "n", m, m, m, &scale, &wsp[iq], m, &h__[h_offset], ldh, &
c_b1, &wsp[ifree], m, (ftnlen)1, (ftnlen)1);
iq = ifree;
} else {
zgemm_("n", "n", m, m, m, &scale, &wsp[ip], m, &h__[h_offset], ldh, &
c_b1, &wsp[ifree], m, (ftnlen)1, (ftnlen)1);
ip = ifree;
}
z__1.r = -1., z__1.i = -0.;
zaxpy_(&mm, &z__1, &wsp[ip], &c__1, &wsp[iq], &c__1);
zgesv_(m, m, &wsp[iq], m, &ipiv[1], &wsp[ip], m, iflag);
if (*iflag != 0) {
s_stop("Problem in ZGESV (within ZGPADM)", (ftnlen)32);
}
zdscal_(&mm, &c_b19, &wsp[ip], &c__1);
i__1 = *m;
for (j = 1; j <= i__1; ++j) {
i__2 = ip + (j - 1) * (*m + 1);
i__3 = ip + (j - 1) * (*m + 1);
z__1.r = wsp[i__3].r + 1., z__1.i = wsp[i__3].i + 0.;
wsp[i__2].r = z__1.r, wsp[i__2].i = z__1.i;
}
iput = ip;
if (*ns == 0 && iodd != 0) {
zdscal_(&mm, &c_b21, &wsp[ip], &c__1);
goto L200;
}
/* -- squaring : exp(t*H) = (exp(t*H))^(2^ns) ... */
iodd = 1;
i__1 = *ns;
for (k = 1; k <= i__1; ++k) {
iget = iodd * ip + (1 - iodd) * iq;
iput = (1 - iodd) * ip + iodd * iq;
zgemm_("n", "n", m, m, m, &c_b2, &wsp[iget], m, &wsp[iget], m, &c_b1,
&wsp[iput], m, (ftnlen)1, (ftnlen)1);
iodd = 1 - iodd;
}
L200:
*iexph = iput;
return 0;
} /* zgpadm_ */
/* Subroutine */ int dlaed0_(integer *icompq, integer *qsiz, integer *n,
doublereal *d, doublereal *e, doublereal *q, integer *ldq, doublereal
*qstore, integer *ldqs, doublereal *work, integer *iwork, 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
=======
DLAED0 computes all eigenvalues and corresponding eigenvectors of a
symmetric tridiagonal matrix using the divide and conquer method.
Arguments
=========
ICOMPQ (input) INTEGER
= 0: Compute eigenvalues only.
= 1: Compute eigenvectors of original dense symmetric matrix
also. On entry, Q contains the orthogonal matrix used
to reduce the original matrix to tridiagonal form.
= 2: Compute eigenvalues and eigenvectors of tridiagonal
matrix.
QSIZ (input) INTEGER
The dimension of the orthogonal matrix used to reduce
the full matrix to tridiagonal form. QSIZ >= N if ICOMPQ = 1.
N (input) INTEGER
The dimension of the symmetric tridiagonal matrix. N >= 0.
D (input/output) DOUBLE PRECISION array, dimension (N)
On entry, the main diagonal of the tridiagonal matrix.
On exit, its eigenvalues.
E (input) DOUBLE PRECISION array, dimension (N-1)
The off-diagonal elements of the tridiagonal matrix.
On exit, E has been destroyed.
Q (input/output) DOUBLE PRECISION array, dimension (LDQ, N)
On entry, Q must contain an N-by-N orthogonal matrix.
If ICOMPQ = 0 Q is not referenced.
If ICOMPQ = 1 On entry, Q is a subset of the columns of the
orthogonal matrix used to reduce the full
matrix to tridiagonal form corresponding to
the subset of the full matrix which is being
decomposed at this time.
If ICOMPQ = 2 On entry, Q will be the identity matrix.
On exit, Q contains the eigenvectors of the
tridiagonal matrix.
LDQ (input) INTEGER
The leading dimension of the array Q. If eigenvectors are
desired, then LDQ >= max(1,N). In any case, LDQ >= 1.
QSTORE (workspace) DOUBLE PRECISION array, dimension (LDQS, N)
Referenced only when ICOMPQ = 1. Used to store parts of
the eigenvector matrix when the updating matrix multiplies
take place.
LDQS (input) INTEGER
The leading dimension of the array QSTORE. If ICOMPQ = 1,
then LDQS >= max(1,N). In any case, LDQS >= 1.
WORK (workspace) DOUBLE PRECISION array,
dimension (1 + 3*N + 2*N*lg N + 2*N**2)
( lg( N ) = smallest integer k
such that 2^k >= N )
IWORK (workspace) INTEGER array,
If ICOMPQ = 0 or 1, the dimension of IWORK must be at least
6 + 6*N + 5*N*lg N.
( lg( N ) = smallest integer k
such that 2^k >= N )
If ICOMPQ = 2, the dimension of IWORK must be at least
2 + 5*N.
INFO (output) INTEGER
= 0: successful exit.
< 0: if INFO = -i, the i-th argument had an illegal value.
> 0: The algorithm failed to compute an eigenvalue while
working on the submatrix lying in rows and columns
INFO/(N+1) through mod(INFO,N+1).
=====================================================================
Test the input parameters.
Parameter adjustments
Function Body */
/* Table of constant values */
static integer c__2 = 2;
static doublereal c_b16 = 1.;
static doublereal c_b17 = 0.;
static integer c__1 = 1;
/* System generated locals */
integer q_dim1, q_offset, qstore_dim1, qstore_offset, i__1, i__2;
doublereal d__1;
/* Builtin functions */
double log(doublereal);
integer pow_ii(integer *, integer *);
/* Local variables */
static doublereal temp;
static integer curr, i, j, k;
extern /* Subroutine */ int dgemm_(char *, char *, integer *, integer *,
integer *, doublereal *, doublereal *, integer *, doublereal *,
integer *, doublereal *, doublereal *, integer *);
static integer iperm;
extern /* Subroutine */ int dcopy_(integer *, doublereal *, integer *,
doublereal *, integer *);
static integer indxq, iwrem;
extern /* Subroutine */ int dlaed1_(integer *, doublereal *, doublereal *,
integer *, integer *, doublereal *, integer *, doublereal *,
integer *, integer *);
static integer iqptr;
extern /* Subroutine */ int dlaed7_(integer *, integer *, integer *,
integer *, integer *, integer *, doublereal *, doublereal *,
integer *, integer *, doublereal *, integer *, doublereal *,
integer *, integer *, integer *, integer *, integer *, doublereal
*, doublereal *, integer *, integer *);
static integer tlvls, iq;
extern /* Subroutine */ int dlacpy_(char *, integer *, integer *,
doublereal *, integer *, doublereal *, integer *);
static integer igivcl;
extern /* Subroutine */ int xerbla_(char *, integer *);
static integer igivnm, submat, curprb, subpbs, igivpt;
extern /* Subroutine */ int dsteqr_(char *, integer *, doublereal *,
doublereal *, doublereal *, integer *, doublereal *, integer *);
static integer curlvl, matsiz, iprmpt, lgn, msd2, smm1, spm1, spm2;
#define D(I) d[(I)-1]
#define E(I) e[(I)-1]
#define WORK(I) work[(I)-1]
#define IWORK(I) iwork[(I)-1]
#define Q(I,J) q[(I)-1 + ((J)-1)* ( *ldq)]
#define QSTORE(I,J) qstore[(I)-1 + ((J)-1)* ( *ldqs)]
*info = 0;
if (*icompq < 0 || *icompq > 2) {
*info = -1;
} else if (*icompq == 1 && *qsiz < max(0,*n)) {
*info = -2;
} else if (*n < 0) {
*info = -3;
} else if (*ldq < max(1,*n)) {
*info = -7;
} else if (*ldqs < max(1,*n)) {
*info = -9;
}
if (*info != 0) {
i__1 = -(*info);
xerbla_("DLAED0", &i__1);
return 0;
}
/* Quick return if possible */
if (*n == 0) {
return 0;
}
/* Determine the size and placement of the submatrices, and save in
the leading elements of IWORK. */
IWORK(1) = *n;
subpbs = 1;
tlvls = 0;
L10:
if (IWORK(subpbs) > 25) {
for (j = subpbs; j >= 1; --j) {
IWORK(j * 2) = (IWORK(j) + 1) / 2;
IWORK((j << 1) - 1) = IWORK(j) / 2;
/* L20: */
}
++tlvls;
subpbs <<= 1;
goto L10;
}
i__1 = subpbs;
for (j = 2; j <= subpbs; ++j) {
IWORK(j) += IWORK(j - 1);
/* L30: */
}
/* Divide the matrix into SUBPBS submatrices of size at most SMLSIZ+1
using rank-1 modifications (cuts). */
spm1 = subpbs - 1;
i__1 = spm1;
for (i = 1; i <= spm1; ++i) {
submat = IWORK(i) + 1;
smm1 = submat - 1;
D(smm1) -= (d__1 = E(smm1), abs(d__1));
D(submat) -= (d__1 = E(smm1), abs(d__1));
/* L40: */
}
indxq = (*n << 2) + 3;
if (*icompq != 2) {
/* Set up workspaces for eigenvalues only/accumulate new vector
s
routine */
temp = log((doublereal) (*n)) / log(2.);
lgn = (integer) temp;
if (pow_ii(&c__2, &lgn) < *n) {
++lgn;
}
if (pow_ii(&c__2, &lgn) < *n) {
++lgn;
}
iprmpt = indxq + *n + 1;
iperm = iprmpt + *n * lgn;
iqptr = iperm + *n * lgn;
igivpt = iqptr + *n + 2;
igivcl = igivpt + *n * lgn;
igivnm = 1;
iq = igivnm + (*n << 1) * lgn;
/* Computing 2nd power */
i__1 = *n;
iwrem = iq + i__1 * i__1 + 1;
/* Initialize pointers */
i__1 = subpbs;
for (i = 0; i <= subpbs; ++i) {
IWORK(iprmpt + i) = 1;
IWORK(igivpt + i) = 1;
/* L50: */
}
IWORK(iqptr) = 1;
}
/* Solve each submatrix eigenproblem at the bottom of the divide and
conquer tree. */
curr = 0;
i__1 = spm1;
for (i = 0; i <= spm1; ++i) {
if (i == 0) {
submat = 1;
matsiz = IWORK(1);
} else {
submat = IWORK(i) + 1;
matsiz = IWORK(i + 1) - IWORK(i);
}
if (*icompq == 2) {
dsteqr_("I", &matsiz, &D(submat), &E(submat), &Q(submat,submat), ldq, &WORK(1), info);
if (*info != 0) {
goto L130;
}
} else {
dsteqr_("I", &matsiz, &D(submat), &E(submat), &WORK(iq - 1 +
IWORK(iqptr + curr)), &matsiz, &WORK(1), info);
if (*info != 0) {
goto L130;
}
if (*icompq == 1) {
dgemm_("N", "N", qsiz, &matsiz, &matsiz, &c_b16, &Q(1,submat), ldq, &WORK(iq - 1 + IWORK(iqptr + curr)),
&matsiz, &c_b17, &QSTORE(1,submat),
ldqs);
}
/* Computing 2nd power */
i__2 = matsiz;
IWORK(iqptr + curr + 1) = IWORK(iqptr + curr) + i__2 * i__2;
++curr;
}
k = 1;
i__2 = IWORK(i + 1);
for (j = submat; j <= IWORK(i+1); ++j) {
IWORK(indxq + j) = k;
++k;
/* L60: */
}
/* L70: */
}
/* Successively merge eigensystems of adjacent submatrices
into eigensystem for the corresponding larger matrix.
while ( SUBPBS > 1 ) */
curlvl = 1;
L80:
if (subpbs > 1) {
spm2 = subpbs - 2;
i__1 = spm2;
for (i = 0; i <= spm2; i += 2) {
if (i == 0) {
submat = 1;
matsiz = IWORK(2);
msd2 = IWORK(1);
curprb = 0;
} else {
submat = IWORK(i) + 1;
matsiz = IWORK(i + 2) - IWORK(i);
msd2 = matsiz / 2;
++curprb;
}
/* Merge lower order eigensystems (of size MSD2 and MATSIZ - M
SD2)
into an eigensystem of size MATSIZ.
DLAED1 is used only for the full eigensystem of a tridiagon
al
matrix.
DLAED7 handles the cases in which eigenvalues only or eigen
values
and eigenvectors of a full symmetric matrix (which was redu
ced to
tridiagonal form) are desired. */
if (*icompq == 2) {
dlaed1_(&matsiz, &D(submat), &Q(submat,submat),
ldq, &IWORK(indxq + submat), &E(submat + msd2 - 1), &
msd2, &WORK(1), &IWORK(subpbs + 1), info);
} else {
dlaed7_(icompq, &matsiz, qsiz, &tlvls, &curlvl, &curprb, &D(
submat), &QSTORE(1,submat), ldqs, &
IWORK(indxq + submat), &E(submat + msd2 - 1), &msd2, &
WORK(iq), &IWORK(iqptr), &IWORK(iprmpt), &IWORK(iperm)
, &IWORK(igivpt), &IWORK(igivcl), &WORK(igivnm), &
WORK(iwrem), &IWORK(subpbs + 1), info);
}
if (*info != 0) {
goto L130;
}
IWORK(i / 2 + 1) = IWORK(i + 2);
/* L90: */
}
subpbs /= 2;
++curlvl;
goto L80;
}
/* end while
Re-merge the eigenvalues/vectors which were deflated at the final
merge step. */
if (*icompq == 1) {
i__1 = *n;
for (i = 1; i <= *n; ++i) {
j = IWORK(indxq + i);
WORK(i) = D(j);
dcopy_(qsiz, &QSTORE(1,j), &c__1, &Q(1,i), &c__1);
/* L100: */
}
dcopy_(n, &WORK(1), &c__1, &D(1), &c__1);
} else if (*icompq == 2) {
i__1 = *n;
for (i = 1; i <= *n; ++i) {
j = IWORK(indxq + i);
WORK(i) = D(j);
dcopy_(n, &Q(1,j), &c__1, &WORK(*n * i + 1), &c__1);
/* L110: */
}
dcopy_(n, &WORK(1), &c__1, &D(1), &c__1);
dlacpy_("A", n, n, &WORK(*n + 1), n, &Q(1,1), ldq);
} else {
i__1 = *n;
for (i = 1; i <= *n; ++i) {
j = IWORK(indxq + i);
WORK(i) = D(j);
/* L120: */
}
dcopy_(n, &WORK(1), &c__1, &D(1), &c__1);
}
goto L140;
L130:
*info = submat * (*n + 1) + submat + matsiz - 1;
L140:
return 0;
/* End of DLAED0 */
} /* dlaed0_ */
/* Subroutine */ int dvfill_(integer *nppa, doublereal *dirvec)
{
/* Initialized data */
static integer kset[60] /* was [2][30] */ = { 1,2,1,3,1,4,1,5,1,6,12,
11,12,10,12,9,12,8,12,7,2,3,3,4,4,5,5,6,6,2,7,8,8,9,9,10,10,11,11,
7,2,7,7,3,3,8,8,4,4,9,9,5,5,10,10,6,6,11,11,2 };
static integer fset[60] /* was [3][20] */ = { 1,2,3,1,3,4,1,4,5,1,5,6,
1,6,2,12,11,10,12,10,9,12,9,8,12,8,7,12,7,11,2,3,7,3,4,8,4,5,9,5,
6,10,6,2,11,7,8,3,8,9,4,9,10,5,10,11,6,11,7,2 };
/* System generated locals */
integer i__1, i__2;
doublereal d__1;
/* Builtin functions */
double sqrt(doublereal), cos(doublereal), sin(doublereal);
integer pow_ii(integer *, integer *);
/* Subroutine */ int s_stop(char *, ftnlen);
/* Local variables */
static doublereal h__;
static integer i__, j, k, l, m;
static doublereal r__, t;
static integer j1, j2, na, nb, nc, nd, kh, ix;
static doublereal beta, dist;
/* FUELLEN DES FELDES DIRVEC */
/* Parameter adjustments */
dirvec -= 4;
/* Function Body */
dirvec[4] = -1.;
dirvec[5] = 0.;
dirvec[6] = 0.;
nd = 1;
r__ = sqrt(.8);
h__ = sqrt(.2);
for (i__ = -1; i__ <= 1; i__ += 2) {
for (j = 1; j <= 5; ++j) {
++nd;
beta = j * 1.25663706 + 1. + (i__ + 1) * .3141593;
dirvec[nd * 3 + 2] = r__ * cos(beta);
dirvec[nd * 3 + 3] = r__ * sin(beta);
dirvec[nd * 3 + 1] = i__ * h__;
/* L10: */
}
}
dirvec[38] = 0.;
dirvec[39] = 0.;
dirvec[37] = 1.;
nd = 12;
/* NPPA=10*3**K*4**L+2 */
m = (*nppa - 2) / 10;
for (k = 0; k <= 10; ++k) {
if (m / 3 * 3 != m) {
goto L30;
}
/* L20: */
m /= 3;
}
L30:
for (l = 0; l <= 10; ++l) {
if (m / 4 << 2 != m) {
goto L50;
}
/* L40: */
m /= 4;
}
L50:
if (pow_ii(&c__3, &k) * 10 * pow_ii(&c__4, &l) + 2 != *nppa) {
s_stop("VALUE OF NPPA NOT ALLOWED: IT MUST BE 10*3**K*4**L+2", (
ftnlen)57);
}
kh = k / 2;
m = pow_ii(&c__2, &l) * pow_ii(&c__3, &kh);
/* CREATE ON EACH EDGE 2**L*3**KH-1 NEW POINTS */
for (i__ = 1; i__ <= 30; ++i__) {
na = kset[(i__ << 1) - 2];
nb = kset[(i__ << 1) - 1];
i__1 = m - 1;
for (j = 1; j <= i__1; ++j) {
++nd;
for (ix = 1; ix <= 3; ++ix) {
/* L60: */
dirvec[ix + nd * 3] = dirvec[ix + na * 3] * (m - j) + dirvec[
ix + nb * 3] * j;
}
/* L70: */
}
}
/* CREATE POINTS WITHIN EACH TRIANGLE */
for (i__ = 1; i__ <= 20; ++i__) {
na = fset[i__ * 3 - 3];
nb = fset[i__ * 3 - 2];
nc = fset[i__ * 3 - 1];
i__1 = m - 1;
for (j1 = 1; j1 <= i__1; ++j1) {
i__2 = m - j1 - 1;
for (j2 = 1; j2 <= i__2; ++j2) {
++nd;
for (ix = 1; ix <= 3; ++ix) {
/* L80: */
dirvec[ix + nd * 3] = dirvec[ix + na * 3] * (m - j1 - j2)
+ dirvec[ix + nb * 3] * j1 + dirvec[ix + nc * 3] *
j2;
}
/* L90: */
}
}
}
if (k == kh << 1) {
goto L140;
}
/* CREATE TO ADDITIONAL SUBGRIDS */
t = .33333333333333331;
for (i__ = 1; i__ <= 20; ++i__) {
na = fset[i__ * 3 - 3];
nb = fset[i__ * 3 - 2];
nc = fset[i__ * 3 - 1];
i__2 = m - 1;
for (j1 = 0; j1 <= i__2; ++j1) {
i__1 = m - j1 - 1;
for (j2 = 0; j2 <= i__1; ++j2) {
++nd;
for (ix = 1; ix <= 3; ++ix) {
/* L100: */
dirvec[ix + nd * 3] = dirvec[ix + na * 3] * (m - j1 - j2
- t * 2) + dirvec[ix + nb * 3] * (j1 + t) +
dirvec[ix + nc * 3] * (j2 + t);
}
/* L110: */
}
}
}
t = .66666666666666663;
for (i__ = 1; i__ <= 20; ++i__) {
na = fset[i__ * 3 - 3];
nb = fset[i__ * 3 - 2];
nc = fset[i__ * 3 - 1];
i__1 = m - 2;
for (j1 = 0; j1 <= i__1; ++j1) {
i__2 = m - j1 - 2;
for (j2 = 0; j2 <= i__2; ++j2) {
++nd;
for (ix = 1; ix <= 3; ++ix) {
/* L120: */
dirvec[ix + nd * 3] = dirvec[ix + na * 3] * (m - j1 - j2
- t * 2) + dirvec[ix + nb * 3] * (j1 + t) +
dirvec[ix + nc * 3] * (j2 + t);
}
/* L130: */
}
}
}
/* NORMALIZE ALL VECTORS */
L140:
i__2 = *nppa;
for (i__ = 1; i__ <= i__2; ++i__) {
dist = 0.;
for (ix = 1; ix <= 3; ++ix) {
/* L150: */
/* Computing 2nd power */
d__1 = dirvec[ix + i__ * 3];
dist += d__1 * d__1;
}
dist = 1. / sqrt(dist);
for (ix = 1; ix <= 3; ++ix) {
/* L160: */
dirvec[ix + i__ * 3] *= dist;
}
/* L170: */
}
return 0;
} /* dvfill_ */
/* Subroutine */ int zlaed0_(integer *qsiz, integer *n, doublereal *d__,
doublereal *e, doublecomplex *q, integer *ldq, doublecomplex *qstore,
integer *ldqs, doublereal *rwork, integer *iwork, 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
=======
Using the divide and conquer method, ZLAED0 computes all eigenvalues
of a symmetric tridiagonal matrix which is one diagonal block of
those from reducing a dense or band Hermitian matrix and
corresponding eigenvectors of the dense or band matrix.
Arguments
=========
QSIZ (input) INTEGER
The dimension of the unitary matrix used to reduce
the full matrix to tridiagonal form. QSIZ >= N if ICOMPQ = 1.
N (input) INTEGER
The dimension of the symmetric tridiagonal matrix. N >= 0.
D (input/output) DOUBLE PRECISION array, dimension (N)
On entry, the diagonal elements of the tridiagonal matrix.
On exit, the eigenvalues in ascending order.
E (input/output) DOUBLE PRECISION array, dimension (N-1)
On entry, the off-diagonal elements of the tridiagonal matrix.
On exit, E has been destroyed.
Q (input/output) COMPLEX*16 array, dimension (LDQ,N)
On entry, Q must contain an QSIZ x N matrix whose columns
unitarily orthonormal. It is a part of the unitary matrix
that reduces the full dense Hermitian matrix to a
(reducible) symmetric tridiagonal matrix.
LDQ (input) INTEGER
The leading dimension of the array Q. LDQ >= max(1,N).
IWORK (workspace) INTEGER array,
the dimension of IWORK must be at least
6 + 6*N + 5*N*lg N
( lg( N ) = smallest integer k
such that 2^k >= N )
RWORK (workspace) DOUBLE PRECISION array,
dimension (1 + 3*N + 2*N*lg N + 3*N**2)
( lg( N ) = smallest integer k
such that 2^k >= N )
QSTORE (workspace) COMPLEX*16 array, dimension (LDQS, N)
Used to store parts of
the eigenvector matrix when the updating matrix multiplies
take place.
LDQS (input) INTEGER
The leading dimension of the array QSTORE.
LDQS >= max(1,N).
INFO (output) INTEGER
= 0: successful exit.
< 0: if INFO = -i, the i-th argument had an illegal value.
> 0: The algorithm failed to compute an eigenvalue while
working on the submatrix lying in rows and columns
INFO/(N+1) through mod(INFO,N+1).
=====================================================================
Warning: N could be as big as QSIZ!
Test the input parameters.
Parameter adjustments */
/* Table of constant values */
static integer c__9 = 9;
static integer c__0 = 0;
static integer c__2 = 2;
static integer c__1 = 1;
/* System generated locals */
integer q_dim1, q_offset, qstore_dim1, qstore_offset, i__1, i__2;
doublereal d__1;
/* Builtin functions */
double log(doublereal);
integer pow_ii(integer *, integer *);
/* Local variables */
static doublereal temp;
static integer curr, i__, j, k, iperm;
extern /* Subroutine */ int dcopy_(integer *, doublereal *, integer *,
doublereal *, integer *);
static integer indxq, iwrem, iqptr, tlvls;
extern /* Subroutine */ int zcopy_(integer *, doublecomplex *, integer *,
doublecomplex *, integer *), zlaed7_(integer *, integer *,
integer *, integer *, integer *, integer *, doublereal *,
doublecomplex *, integer *, doublereal *, integer *, doublereal *,
integer *, integer *, integer *, integer *, integer *,
doublereal *, doublecomplex *, doublereal *, integer *, integer *)
;
static integer ll, iq, igivcl;
extern /* Subroutine */ int xerbla_(char *, integer *);
extern integer ilaenv_(integer *, char *, char *, integer *, integer *,
integer *, integer *, ftnlen, ftnlen);
extern /* Subroutine */ int zlacrm_(integer *, integer *, doublecomplex *,
integer *, doublereal *, integer *, doublecomplex *, integer *,
doublereal *);
static integer igivnm, submat, curprb, subpbs, igivpt;
extern /* Subroutine */ int dsteqr_(char *, integer *, doublereal *,
doublereal *, doublereal *, integer *, doublereal *, integer *);
static integer curlvl, matsiz, iprmpt, smlsiz, lgn, msd2, smm1, spm1,
spm2;
#define q_subscr(a_1,a_2) (a_2)*q_dim1 + a_1
#define q_ref(a_1,a_2) q[q_subscr(a_1,a_2)]
#define qstore_subscr(a_1,a_2) (a_2)*qstore_dim1 + a_1
#define qstore_ref(a_1,a_2) qstore[qstore_subscr(a_1,a_2)]
--d__;
--e;
q_dim1 = *ldq;
q_offset = 1 + q_dim1 * 1;
q -= q_offset;
qstore_dim1 = *ldqs;
qstore_offset = 1 + qstore_dim1 * 1;
qstore -= qstore_offset;
--rwork;
--iwork;
/* Function Body */
*info = 0;
/* IF( ICOMPQ .LT. 0 .OR. ICOMPQ .GT. 2 ) THEN
INFO = -1
ELSE IF( ( ICOMPQ .EQ. 1 ) .AND. ( QSIZ .LT. MAX( 0, N ) ) )
$ THEN */
if (*qsiz < max(0,*n)) {
*info = -1;
} else if (*n < 0) {
*info = -2;
} else if (*ldq < max(1,*n)) {
*info = -6;
} else if (*ldqs < max(1,*n)) {
*info = -8;
}
if (*info != 0) {
i__1 = -(*info);
xerbla_("ZLAED0", &i__1);
return 0;
}
/* Quick return if possible */
if (*n == 0) {
return 0;
}
smlsiz = ilaenv_(&c__9, "ZLAED0", " ", &c__0, &c__0, &c__0, &c__0, (
ftnlen)6, (ftnlen)1);
/* Determine the size and placement of the submatrices, and save in
the leading elements of IWORK. */
iwork[1] = *n;
subpbs = 1;
tlvls = 0;
L10:
if (iwork[subpbs] > smlsiz) {
for (j = subpbs; j >= 1; --j) {
iwork[j * 2] = (iwork[j] + 1) / 2;
iwork[(j << 1) - 1] = iwork[j] / 2;
/* L20: */
}
++tlvls;
subpbs <<= 1;
goto L10;
}
i__1 = subpbs;
for (j = 2; j <= i__1; ++j) {
iwork[j] += iwork[j - 1];
/* L30: */
}
/* Divide the matrix into SUBPBS submatrices of size at most SMLSIZ+1
using rank-1 modifications (cuts). */
spm1 = subpbs - 1;
i__1 = spm1;
for (i__ = 1; i__ <= i__1; ++i__) {
submat = iwork[i__] + 1;
smm1 = submat - 1;
d__[smm1] -= (d__1 = e[smm1], abs(d__1));
d__[submat] -= (d__1 = e[smm1], abs(d__1));
/* L40: */
}
indxq = (*n << 2) + 3;
/* Set up workspaces for eigenvalues only/accumulate new vectors
routine */
temp = log((doublereal) (*n)) / log(2.);
lgn = (integer) temp;
if (pow_ii(&c__2, &lgn) < *n) {
++lgn;
}
if (pow_ii(&c__2, &lgn) < *n) {
++lgn;
}
iprmpt = indxq + *n + 1;
iperm = iprmpt + *n * lgn;
iqptr = iperm + *n * lgn;
igivpt = iqptr + *n + 2;
igivcl = igivpt + *n * lgn;
igivnm = 1;
iq = igivnm + (*n << 1) * lgn;
/* Computing 2nd power */
i__1 = *n;
iwrem = iq + i__1 * i__1 + 1;
/* Initialize pointers */
i__1 = subpbs;
for (i__ = 0; i__ <= i__1; ++i__) {
iwork[iprmpt + i__] = 1;
iwork[igivpt + i__] = 1;
/* L50: */
}
iwork[iqptr] = 1;
/* Solve each submatrix eigenproblem at the bottom of the divide and
conquer tree. */
curr = 0;
i__1 = spm1;
for (i__ = 0; i__ <= i__1; ++i__) {
if (i__ == 0) {
submat = 1;
matsiz = iwork[1];
} else {
submat = iwork[i__] + 1;
matsiz = iwork[i__ + 1] - iwork[i__];
}
ll = iq - 1 + iwork[iqptr + curr];
dsteqr_("I", &matsiz, &d__[submat], &e[submat], &rwork[ll], &matsiz, &
rwork[1], info);
zlacrm_(qsiz, &matsiz, &q_ref(1, submat), ldq, &rwork[ll], &matsiz, &
qstore_ref(1, submat), ldqs, &rwork[iwrem]);
/* Computing 2nd power */
i__2 = matsiz;
iwork[iqptr + curr + 1] = iwork[iqptr + curr] + i__2 * i__2;
++curr;
if (*info > 0) {
*info = submat * (*n + 1) + submat + matsiz - 1;
return 0;
}
k = 1;
i__2 = iwork[i__ + 1];
for (j = submat; j <= i__2; ++j) {
iwork[indxq + j] = k;
++k;
/* L60: */
}
/* L70: */
}
/* Successively merge eigensystems of adjacent submatrices
into eigensystem for the corresponding larger matrix.
while ( SUBPBS > 1 ) */
curlvl = 1;
L80:
if (subpbs > 1) {
spm2 = subpbs - 2;
i__1 = spm2;
for (i__ = 0; i__ <= i__1; i__ += 2) {
if (i__ == 0) {
submat = 1;
matsiz = iwork[2];
msd2 = iwork[1];
curprb = 0;
} else {
submat = iwork[i__] + 1;
matsiz = iwork[i__ + 2] - iwork[i__];
msd2 = matsiz / 2;
++curprb;
}
/* Merge lower order eigensystems (of size MSD2 and MATSIZ - MSD2)
into an eigensystem of size MATSIZ. ZLAED7 handles the case
when the eigenvectors of a full or band Hermitian matrix (which
was reduced to tridiagonal form) are desired.
I am free to use Q as a valuable working space until Loop 150. */
zlaed7_(&matsiz, &msd2, qsiz, &tlvls, &curlvl, &curprb, &d__[
submat], &qstore_ref(1, submat), ldqs, &e[submat + msd2 -
1], &iwork[indxq + submat], &rwork[iq], &iwork[iqptr], &
iwork[iprmpt], &iwork[iperm], &iwork[igivpt], &iwork[
igivcl], &rwork[igivnm], &q_ref(1, submat), &rwork[iwrem],
&iwork[subpbs + 1], info);
if (*info > 0) {
*info = submat * (*n + 1) + submat + matsiz - 1;
return 0;
}
iwork[i__ / 2 + 1] = iwork[i__ + 2];
/* L90: */
}
subpbs /= 2;
++curlvl;
goto L80;
}
/* end while
Re-merge the eigenvalues/vectors which were deflated at the final
merge step. */
i__1 = *n;
for (i__ = 1; i__ <= i__1; ++i__) {
j = iwork[indxq + i__];
rwork[i__] = d__[j];
zcopy_(qsiz, &qstore_ref(1, j), &c__1, &q_ref(1, i__), &c__1);
/* L100: */
}
dcopy_(n, &rwork[1], &c__1, &d__[1], &c__1);
return 0;
/* End of ZLAED0 */
} /* zlaed0_ */
/*< subroutine gpfa3f(a,b,trigs,inc,jump,n,mm,lot,isign) >*/
/* Subroutine */ int gpfa3f_(real *a, real *b, real *trigs, integer *inc,
integer *jump, integer *n, integer *mm, integer *lot, integer *isign)
{
/* Initialized data */
static real sin60 = (float).866025403784437; /* constant */
static integer lvr = 128; /* constant */
/* System generated locals */
integer i__1, i__2, i__3, i__4, i__5, i__6, i__7, i__8, i__9, i__10;
/* Builtin functions */
integer pow_ii(integer *, integer *);
/* Local variables */
integer j, k, l, m;
real s, c1;
integer n3;
real t1, t2, t3, u1, u2, u3;
integer ja, jb, la, jc, jd, nb, je, jf, jg, jh, mh, kk, ji, ll, mu, nu;
real co1, co2, si1, si2, aja, ajb, ajc, bjb, bjc, bja, ajd, bjd, aje, ajf,
ajh, bje, bjf, bjh, aji, ajg, bji, bjg;
integer jjj, ink, inq, ninc, left, nvex, ipass, nblox, jstep, laincl,
jstepl, istart, jstepx;
/*< real a(*), b(*), trigs(*) >*/
/*< integer inc, jump, n, mm, lot, isign >*/
/*< real s, c1, t1, t2, t3, u1, u2, u3, co1, co2 >*/
/*< real si1, si2, aja, ajb, ajc, bjb, bjc, bja, ajd, bjd >*/
/*< real aje, ajf, ajh, bje, bjf, bjh, aji, ajg, bji, bjg >*/
/*< data sin60/0.866025403784437/ >*/
/* Parameter adjustments */
--trigs;
--b;
--a;
/* Function Body */
/*< data lvr/128/ >*/
/* *************************************************************** */
/* * * */
/* * N.B. LVR = LENGTH OF VECTOR REGISTERS, SET TO 128 FOR C90. * */
/* * RESET TO 64 FOR OTHER CRAY MACHINES, OR TO ANY LARGE VALUE * */
/* * (GREATER THAN OR EQUAL TO LOT) FOR A SCALAR COMPUTER. * */
/* * * */
/* *************************************************************** */
/*< n3 = 3**mm >*/
n3 = pow_ii(&c__3, mm);
/*< inq = n/n3 >*/
inq = *n / n3;
/*< jstepx = (n3-n) * inc >*/
jstepx = (n3 - *n) * *inc;
/*< ninc = n * inc >*/
ninc = *n * *inc;
/*< ink = inc * inq >*/
ink = *inc * inq;
/*< mu = mod(inq,3) >*/
mu = inq % 3;
/*< if (isign.eq.-1) mu = 3-mu >*/
if (*isign == -1) {
mu = 3 - mu;
}
/*< m = mm >*/
m = *mm;
/*< mh = (m+1)/2 >*/
mh = (m + 1) / 2;
/*< s = float(isign) >*/
s = (real) (*isign);
/*< c1 = sin60 >*/
c1 = sin60;
/*< if (mu.eq.2) c1 = -c1 >*/
if (mu == 2) {
c1 = -c1;
}
/*< nblox = 1 + (lot-1)/lvr >*/
nblox = (*lot - 1) / lvr + 1;
/*< left = lot >*/
left = *lot;
/*< s = float(isign) >*/
s = (real) (*isign);
/*< istart = 1 >*/
istart = 1;
/* loop on blocks of lvr transforms */
/* -------------------------------- */
/*< do 500 nb = 1 , nblox >*/
i__1 = nblox;
for (nb = 1; nb <= i__1; ++nb) {
/*< if (left.le.lvr) then >*/
if (left <= lvr) {
/*< nvex = left >*/
nvex = left;
/*< else if (left.lt.(2*lvr)) then >*/
} else if (left < lvr << 1) {
/*< nvex = left/2 >*/
nvex = left / 2;
/*< nvex = nvex + mod(nvex,2) >*/
nvex += nvex % 2;
/*< else >*/
} else {
/*< nvex = lvr >*/
nvex = lvr;
/*< endif >*/
}
/*< left = left - nvex >*/
left -= nvex;
/*< la = 1 >*/
la = 1;
/* loop on type I radix-3 passes */
/* ----------------------------- */
/*< do 160 ipass = 1 , mh >*/
i__2 = mh;
for (ipass = 1; ipass <= i__2; ++ipass) {
/*< jstep = (n*inc) / (3*la) >*/
jstep = *n * *inc / (la * 3);
/*< jstepl = jstep - ninc >*/
jstepl = jstep - ninc;
/* k = 0 loop (no twiddle factors) */
/* ------------------------------- */
/*< do 120 jjj = 0 , (n-1)*inc , 3*jstep >*/
i__3 = (*n - 1) * *inc;
i__4 = jstep * 3;
for (jjj = 0; i__4 < 0 ? jjj >= i__3 : jjj <= i__3; jjj += i__4) {
/*< ja = istart + jjj >*/
ja = istart + jjj;
/* "transverse" loop */
/* ----------------- */
/*< do 115 nu = 1 , inq >*/
i__5 = inq;
for (nu = 1; nu <= i__5; ++nu) {
/*< jb = ja + jstepl >*/
jb = ja + jstepl;
/*< if (jb.lt.istart) jb = jb + ninc >*/
if (jb < istart) {
jb += ninc;
}
/*< jc = jb + jstepl >*/
jc = jb + jstepl;
/*< if (jc.lt.istart) jc = jc + ninc >*/
if (jc < istart) {
jc += ninc;
}
/*< j = 0 >*/
j = 0;
/* loop across transforms */
/* ---------------------- */
/* dir$ ivdep, shortloop */
/*< do 110 l = 1 , nvex >*/
i__6 = nvex;
for (l = 1; l <= i__6; ++l) {
/*< ajb = a(jb+j) >*/
ajb = a[jb + j];
/*< ajc = a(jc+j) >*/
ajc = a[jc + j];
/*< t1 = ajb + ajc >*/
t1 = ajb + ajc;
/*< aja = a(ja+j) >*/
aja = a[ja + j];
/*< t2 = aja - 0.5 * t1 >*/
t2 = aja - t1 * (float).5;
/*< t3 = c1 * ( ajb - ajc ) >*/
t3 = c1 * (ajb - ajc);
/*< bjb = b(jb+j) >*/
bjb = b[jb + j];
/*< bjc = b(jc+j) >*/
bjc = b[jc + j];
/*< u1 = bjb + bjc >*/
u1 = bjb + bjc;
/*< bja = b(ja+j) >*/
bja = b[ja + j];
/*< u2 = bja - 0.5 * u1 >*/
u2 = bja - u1 * (float).5;
/*< u3 = c1 * ( bjb - bjc ) >*/
u3 = c1 * (bjb - bjc);
/*< a(ja+j) = aja + t1 >*/
a[ja + j] = aja + t1;
/*< b(ja+j) = bja + u1 >*/
b[ja + j] = bja + u1;
/*< a(jb+j) = t2 - u3 >*/
a[jb + j] = t2 - u3;
/*< b(jb+j) = u2 + t3 >*/
b[jb + j] = u2 + t3;
/*< a(jc+j) = t2 + u3 >*/
a[jc + j] = t2 + u3;
/*< b(jc+j) = u2 - t3 >*/
b[jc + j] = u2 - t3;
/*< j = j + jump >*/
j += *jump;
/*< 110 continue >*/
/* L110: */
}
/*< ja = ja + jstepx >*/
ja += jstepx;
/*< if (ja.lt.istart) ja = ja + ninc >*/
if (ja < istart) {
ja += ninc;
}
/*< 115 continue >*/
/* L115: */
}
/*< 120 continue >*/
/* L120: */
}
/* finished if n3 = 3 */
/* ------------------ */
/*< if (n3.eq.3) go to 490 >*/
if (n3 == 3) {
goto L490;
}
/*< kk = 2 * la >*/
kk = la << 1;
/* loop on nonzero k */
/* ----------------- */
/*< do 150 k = ink , jstep-ink , ink >*/
i__4 = jstep - ink;
i__3 = ink;
for (k = ink; i__3 < 0 ? k >= i__4 : k <= i__4; k += i__3) {
/*< co1 = trigs(kk+1) >*/
co1 = trigs[kk + 1];
/*< si1 = s*trigs(kk+2) >*/
si1 = s * trigs[kk + 2];
/*< co2 = trigs(2*kk+1) >*/
co2 = trigs[(kk << 1) + 1];
/*< si2 = s*trigs(2*kk+2) >*/
si2 = s * trigs[(kk << 1) + 2];
/* loop along transform */
/* -------------------- */
/*< do 140 jjj = k , (n-1)*inc , 3*jstep >*/
i__5 = (*n - 1) * *inc;
i__6 = jstep * 3;
for (jjj = k; i__6 < 0 ? jjj >= i__5 : jjj <= i__5; jjj +=
i__6) {
/*< ja = istart + jjj >*/
ja = istart + jjj;
/* "transverse" loop */
/* ----------------- */
/*< do 135 nu = 1 , inq >*/
i__7 = inq;
for (nu = 1; nu <= i__7; ++nu) {
/*< jb = ja + jstepl >*/
jb = ja + jstepl;
/*< if (jb.lt.istart) jb = jb + ninc >*/
if (jb < istart) {
jb += ninc;
}
/*< jc = jb + jstepl >*/
jc = jb + jstepl;
/*< if (jc.lt.istart) jc = jc + ninc >*/
if (jc < istart) {
jc += ninc;
}
/*< j = 0 >*/
j = 0;
/* loop across transforms */
/* ---------------------- */
/* dir$ ivdep,shortloop */
/*< do 130 l = 1 , nvex >*/
i__8 = nvex;
for (l = 1; l <= i__8; ++l) {
/*< ajb = a(jb+j) >*/
ajb = a[jb + j];
/*< ajc = a(jc+j) >*/
ajc = a[jc + j];
/*< t1 = ajb + ajc >*/
t1 = ajb + ajc;
/*< aja = a(ja+j) >*/
aja = a[ja + j];
/*< t2 = aja - 0.5 * t1 >*/
t2 = aja - t1 * (float).5;
/*< t3 = c1 * ( ajb - ajc ) >*/
t3 = c1 * (ajb - ajc);
/*< bjb = b(jb+j) >*/
bjb = b[jb + j];
/*< bjc = b(jc+j) >*/
bjc = b[jc + j];
/*< u1 = bjb + bjc >*/
u1 = bjb + bjc;
/*< bja = b(ja+j) >*/
bja = b[ja + j];
/*< u2 = bja - 0.5 * u1 >*/
u2 = bja - u1 * (float).5;
/*< u3 = c1 * ( bjb - bjc ) >*/
u3 = c1 * (bjb - bjc);
/*< a(ja+j) = aja + t1 >*/
a[ja + j] = aja + t1;
/*< b(ja+j) = bja + u1 >*/
b[ja + j] = bja + u1;
/*< a(jb+j) = co1*(t2-u3) - si1*(u2+t3) >*/
a[jb + j] = co1 * (t2 - u3) - si1 * (u2 + t3);
/*< b(jb+j) = si1*(t2-u3) + co1*(u2+t3) >*/
b[jb + j] = si1 * (t2 - u3) + co1 * (u2 + t3);
/*< a(jc+j) = co2*(t2+u3) - si2*(u2-t3) >*/
a[jc + j] = co2 * (t2 + u3) - si2 * (u2 - t3);
/*< b(jc+j) = si2*(t2+u3) + co2*(u2-t3) >*/
b[jc + j] = si2 * (t2 + u3) + co2 * (u2 - t3);
/*< j = j + jump >*/
j += *jump;
/*< 130 continue >*/
/* L130: */
}
/* -----( end of loop across transforms ) */
/*< ja = ja + jstepx >*/
ja += jstepx;
/*< if (ja.lt.istart) ja = ja + ninc >*/
if (ja < istart) {
ja += ninc;
}
/*< 135 continue >*/
/* L135: */
}
/*< 140 continue >*/
/* L140: */
}
/* -----( end of loop along transforms ) */
/*< kk = kk + 2*la >*/
kk += la << 1;
/*< 150 continue >*/
/* L150: */
}
/* -----( end of loop on nonzero k ) */
/*< la = 3*la >*/
la *= 3;
/*< 160 continue >*/
/* L160: */
}
/* -----( end of loop on type I radix-3 passes) */
/* loop on type II radix-3 passes */
/* ------------------------------ */
/*< 400 continue >*/
/* L400: */
/*< do 480 ipass = mh+1 , m >*/
i__2 = m;
for (ipass = mh + 1; ipass <= i__2; ++ipass) {
/*< jstep = (n*inc) / (3*la) >*/
jstep = *n * *inc / (la * 3);
/*< jstepl = jstep - ninc >*/
jstepl = jstep - ninc;
/*< laincl = la*ink - ninc >*/
laincl = la * ink - ninc;
/* k=0 loop (no twiddle factors) */
/* ----------------------------- */
/*< do 430 ll = 0 , (la-1)*ink , 3*jstep >*/
i__3 = (la - 1) * ink;
i__4 = jstep * 3;
for (ll = 0; i__4 < 0 ? ll >= i__3 : ll <= i__3; ll += i__4) {
/*< do 420 jjj = ll , (n-1)*inc , 3*la*ink >*/
i__6 = (*n - 1) * *inc;
i__5 = la * 3 * ink;
for (jjj = ll; i__5 < 0 ? jjj >= i__6 : jjj <= i__6; jjj +=
i__5) {
/*< ja = istart + jjj >*/
ja = istart + jjj;
/* "transverse" loop */
/* ----------------- */
/*< do 415 nu = 1 , inq >*/
i__7 = inq;
for (nu = 1; nu <= i__7; ++nu) {
/*< jb = ja + jstepl >*/
jb = ja + jstepl;
/*< if (jb.lt.istart) jb = jb + ninc >*/
if (jb < istart) {
jb += ninc;
}
/*< jc = jb + jstepl >*/
jc = jb + jstepl;
/*< if (jc.lt.istart) jc = jc + ninc >*/
if (jc < istart) {
jc += ninc;
}
/*< jd = ja + laincl >*/
jd = ja + laincl;
/*< if (jd.lt.istart) jd = jd + ninc >*/
if (jd < istart) {
jd += ninc;
}
/*< je = jd + jstepl >*/
je = jd + jstepl;
/*< if (je.lt.istart) je = je + ninc >*/
if (je < istart) {
je += ninc;
}
/*< jf = je + jstepl >*/
jf = je + jstepl;
/*< if (jf.lt.istart) jf = jf + ninc >*/
if (jf < istart) {
jf += ninc;
}
/*< jg = jd + laincl >*/
jg = jd + laincl;
/*< if (jg.lt.istart) jg = jg + ninc >*/
if (jg < istart) {
jg += ninc;
}
/*< jh = jg + jstepl >*/
jh = jg + jstepl;
/*< if (jh.lt.istart) jh = jh + ninc >*/
if (jh < istart) {
jh += ninc;
}
/*< ji = jh + jstepl >*/
ji = jh + jstepl;
/*< if (ji.lt.istart) ji = ji + ninc >*/
if (ji < istart) {
ji += ninc;
}
/*< j = 0 >*/
j = 0;
/* loop across transforms */
/* ---------------------- */
/* dir$ ivdep, shortloop */
/*< do 410 l = 1 , nvex >*/
i__8 = nvex;
for (l = 1; l <= i__8; ++l) {
/*< ajb = a(jb+j) >*/
ajb = a[jb + j];
/*< ajc = a(jc+j) >*/
ajc = a[jc + j];
/*< t1 = ajb + ajc >*/
t1 = ajb + ajc;
/*< aja = a(ja+j) >*/
aja = a[ja + j];
/*< t2 = aja - 0.5 * t1 >*/
t2 = aja - t1 * (float).5;
/*< t3 = c1 * ( ajb - ajc ) >*/
t3 = c1 * (ajb - ajc);
/*< ajd = a(jd+j) >*/
ajd = a[jd + j];
/*< ajb = ajd >*/
ajb = ajd;
/*< bjb = b(jb+j) >*/
bjb = b[jb + j];
/*< bjc = b(jc+j) >*/
bjc = b[jc + j];
/*< u1 = bjb + bjc >*/
u1 = bjb + bjc;
/*< bja = b(ja+j) >*/
bja = b[ja + j];
/*< u2 = bja - 0.5 * u1 >*/
u2 = bja - u1 * (float).5;
/*< u3 = c1 * ( bjb - bjc ) >*/
u3 = c1 * (bjb - bjc);
/*< bjd = b(jd+j) >*/
bjd = b[jd + j];
/*< bjb = bjd >*/
bjb = bjd;
/*< a(ja+j) = aja + t1 >*/
a[ja + j] = aja + t1;
/*< b(ja+j) = bja + u1 >*/
b[ja + j] = bja + u1;
/*< a(jd+j) = t2 - u3 >*/
a[jd + j] = t2 - u3;
/*< b(jd+j) = u2 + t3 >*/
b[jd + j] = u2 + t3;
/*< ajc = t2 + u3 >*/
ajc = t2 + u3;
/*< bjc = u2 - t3 >*/
bjc = u2 - t3;
/* ---------------------- */
/*< aje = a(je+j) >*/
aje = a[je + j];
/*< ajf = a(jf+j) >*/
ajf = a[jf + j];
/*< t1 = aje + ajf >*/
t1 = aje + ajf;
/*< t2 = ajb - 0.5 * t1 >*/
t2 = ajb - t1 * (float).5;
/*< t3 = c1 * ( aje - ajf ) >*/
t3 = c1 * (aje - ajf);
/*< ajh = a(jh+j) >*/
ajh = a[jh + j];
/*< ajf = ajh >*/
ajf = ajh;
/*< bje = b(je+j) >*/
bje = b[je + j];
/*< bjf = b(jf+j) >*/
bjf = b[jf + j];
/*< u1 = bje + bjf >*/
u1 = bje + bjf;
/*< u2 = bjb - 0.5 * u1 >*/
u2 = bjb - u1 * (float).5;
/*< u3 = c1 * ( bje - bjf ) >*/
u3 = c1 * (bje - bjf);
/*< bjh = b(jh+j) >*/
bjh = b[jh + j];
/*< bjf = bjh >*/
bjf = bjh;
/*< a(jb+j) = ajb + t1 >*/
a[jb + j] = ajb + t1;
/*< b(jb+j) = bjb + u1 >*/
b[jb + j] = bjb + u1;
/*< a(je+j) = t2 - u3 >*/
a[je + j] = t2 - u3;
/*< b(je+j) = u2 + t3 >*/
b[je + j] = u2 + t3;
/*< a(jh+j) = t2 + u3 >*/
a[jh + j] = t2 + u3;
/*< b(jh+j) = u2 - t3 >*/
b[jh + j] = u2 - t3;
/* ---------------------- */
/*< aji = a(ji+j) >*/
aji = a[ji + j];
/*< t1 = ajf + aji >*/
t1 = ajf + aji;
/*< ajg = a(jg+j) >*/
ajg = a[jg + j];
/*< t2 = ajg - 0.5 * t1 >*/
t2 = ajg - t1 * (float).5;
/*< t3 = c1 * ( ajf - aji ) >*/
t3 = c1 * (ajf - aji);
/*< t1 = ajg + t1 >*/
t1 = ajg + t1;
/*< a(jg+j) = ajc >*/
a[jg + j] = ajc;
/*< bji = b(ji+j) >*/
bji = b[ji + j];
/*< u1 = bjf + bji >*/
u1 = bjf + bji;
/*< bjg = b(jg+j) >*/
bjg = b[jg + j];
/*< u2 = bjg - 0.5 * u1 >*/
u2 = bjg - u1 * (float).5;
/*< u3 = c1 * ( bjf - bji ) >*/
u3 = c1 * (bjf - bji);
/*< u1 = bjg + u1 >*/
u1 = bjg + u1;
/*< b(jg+j) = bjc >*/
b[jg + j] = bjc;
/*< a(jc+j) = t1 >*/
a[jc + j] = t1;
/*< b(jc+j) = u1 >*/
b[jc + j] = u1;
/*< a(jf+j) = t2 - u3 >*/
a[jf + j] = t2 - u3;
/*< b(jf+j) = u2 + t3 >*/
b[jf + j] = u2 + t3;
/*< a(ji+j) = t2 + u3 >*/
a[ji + j] = t2 + u3;
/*< b(ji+j) = u2 - t3 >*/
b[ji + j] = u2 - t3;
/*< j = j + jump >*/
j += *jump;
/*< 410 continue >*/
/* L410: */
}
/* -----( end of loop across transforms ) */
/*< ja = ja + jstepx >*/
ja += jstepx;
/*< if (ja.lt.istart) ja = ja + ninc >*/
if (ja < istart) {
ja += ninc;
}
/*< 415 continue >*/
/* L415: */
}
/*< 420 continue >*/
/* L420: */
}
/*< 430 continue >*/
/* L430: */
}
/* -----( end of double loop for k=0 ) */
/* finished if last pass */
/* --------------------- */
/*< if (ipass.eq.m) go to 490 >*/
if (ipass == m) {
goto L490;
}
/*< kk = 2*la >*/
kk = la << 1;
/* loop on nonzero k */
/* ----------------- */
/*< do 470 k = ink , jstep-ink , ink >*/
i__4 = jstep - ink;
i__3 = ink;
for (k = ink; i__3 < 0 ? k >= i__4 : k <= i__4; k += i__3) {
/*< co1 = trigs(kk+1) >*/
co1 = trigs[kk + 1];
/*< si1 = s*trigs(kk+2) >*/
si1 = s * trigs[kk + 2];
/*< co2 = trigs(2*kk+1) >*/
co2 = trigs[(kk << 1) + 1];
/*< si2 = s*trigs(2*kk+2) >*/
si2 = s * trigs[(kk << 1) + 2];
/* double loop along first transform in block */
/* ------------------------------------------ */
/*< do 460 ll = k , (la-1)*ink , 3*jstep >*/
i__5 = (la - 1) * ink;
i__6 = jstep * 3;
for (ll = k; i__6 < 0 ? ll >= i__5 : ll <= i__5; ll += i__6) {
/*< do 450 jjj = ll , (n-1)*inc , 3*la*ink >*/
i__7 = (*n - 1) * *inc;
i__8 = la * 3 * ink;
for (jjj = ll; i__8 < 0 ? jjj >= i__7 : jjj <= i__7; jjj
+= i__8) {
/*< ja = istart + jjj >*/
ja = istart + jjj;
/* "transverse" loop */
/* ----------------- */
/*< do 445 nu = 1 , inq >*/
i__9 = inq;
for (nu = 1; nu <= i__9; ++nu) {
/*< jb = ja + jstepl >*/
jb = ja + jstepl;
/*< if (jb.lt.istart) jb = jb + ninc >*/
if (jb < istart) {
jb += ninc;
}
/*< jc = jb + jstepl >*/
jc = jb + jstepl;
/*< if (jc.lt.istart) jc = jc + ninc >*/
if (jc < istart) {
jc += ninc;
}
/*< jd = ja + laincl >*/
jd = ja + laincl;
/*< if (jd.lt.istart) jd = jd + ninc >*/
if (jd < istart) {
jd += ninc;
}
/*< je = jd + jstepl >*/
je = jd + jstepl;
/*< if (je.lt.istart) je = je + ninc >*/
if (je < istart) {
je += ninc;
}
/*< jf = je + jstepl >*/
jf = je + jstepl;
/*< if (jf.lt.istart) jf = jf + ninc >*/
if (jf < istart) {
jf += ninc;
}
/*< jg = jd + laincl >*/
jg = jd + laincl;
/*< if (jg.lt.istart) jg = jg + ninc >*/
if (jg < istart) {
jg += ninc;
}
/*< jh = jg + jstepl >*/
jh = jg + jstepl;
/*< if (jh.lt.istart) jh = jh + ninc >*/
if (jh < istart) {
jh += ninc;
}
/*< ji = jh + jstepl >*/
ji = jh + jstepl;
/*< if (ji.lt.istart) ji = ji + ninc >*/
if (ji < istart) {
ji += ninc;
}
/*< j = 0 >*/
j = 0;
/* loop across transforms */
/* ---------------------- */
/* dir$ ivdep, shortloop */
/*< do 440 l = 1 , nvex >*/
i__10 = nvex;
for (l = 1; l <= i__10; ++l) {
/*< ajb = a(jb+j) >*/
ajb = a[jb + j];
/*< ajc = a(jc+j) >*/
ajc = a[jc + j];
/*< t1 = ajb + ajc >*/
t1 = ajb + ajc;
/*< aja = a(ja+j) >*/
aja = a[ja + j];
/*< t2 = aja - 0.5 * t1 >*/
t2 = aja - t1 * (float).5;
/*< t3 = c1 * ( ajb - ajc ) >*/
t3 = c1 * (ajb - ajc);
/*< ajd = a(jd+j) >*/
ajd = a[jd + j];
/*< ajb = ajd >*/
ajb = ajd;
/*< bjb = b(jb+j) >*/
bjb = b[jb + j];
/*< bjc = b(jc+j) >*/
bjc = b[jc + j];
/*< u1 = bjb + bjc >*/
u1 = bjb + bjc;
/*< bja = b(ja+j) >*/
bja = b[ja + j];
/*< u2 = bja - 0.5 * u1 >*/
u2 = bja - u1 * (float).5;
/*< u3 = c1 * ( bjb - bjc ) >*/
u3 = c1 * (bjb - bjc);
/*< bjd = b(jd+j) >*/
bjd = b[jd + j];
/*< bjb = bjd >*/
bjb = bjd;
/*< a(ja+j) = aja + t1 >*/
a[ja + j] = aja + t1;
/*< b(ja+j) = bja + u1 >*/
b[ja + j] = bja + u1;
/*< a(jd+j) = co1*(t2-u3) - si1*(u2+t3) >*/
a[jd + j] = co1 * (t2 - u3) - si1 * (u2 + t3);
/*< b(jd+j) = si1*(t2-u3) + co1*(u2+t3) >*/
b[jd + j] = si1 * (t2 - u3) + co1 * (u2 + t3);
/*< ajc = co2*(t2+u3) - si2*(u2-t3) >*/
ajc = co2 * (t2 + u3) - si2 * (u2 - t3);
/*< bjc = si2*(t2+u3) + co2*(u2-t3) >*/
bjc = si2 * (t2 + u3) + co2 * (u2 - t3);
/* ---------------------- */
/*< aje = a(je+j) >*/
aje = a[je + j];
/*< ajf = a(jf+j) >*/
ajf = a[jf + j];
/*< t1 = aje + ajf >*/
t1 = aje + ajf;
/*< t2 = ajb - 0.5 * t1 >*/
t2 = ajb - t1 * (float).5;
/*< t3 = c1 * ( aje - ajf ) >*/
t3 = c1 * (aje - ajf);
/*< ajh = a(jh+j) >*/
ajh = a[jh + j];
/*< ajf = ajh >*/
ajf = ajh;
/*< bje = b(je+j) >*/
bje = b[je + j];
/*< bjf = b(jf+j) >*/
bjf = b[jf + j];
/*< u1 = bje + bjf >*/
u1 = bje + bjf;
/*< u2 = bjb - 0.5 * u1 >*/
u2 = bjb - u1 * (float).5;
/*< u3 = c1 * ( bje - bjf ) >*/
u3 = c1 * (bje - bjf);
/*< bjh = b(jh+j) >*/
bjh = b[jh + j];
/*< bjf = bjh >*/
bjf = bjh;
/*< a(jb+j) = ajb + t1 >*/
a[jb + j] = ajb + t1;
/*< b(jb+j) = bjb + u1 >*/
b[jb + j] = bjb + u1;
/*< a(je+j) = co1*(t2-u3) - si1*(u2+t3) >*/
a[je + j] = co1 * (t2 - u3) - si1 * (u2 + t3);
/*< b(je+j) = si1*(t2-u3) + co1*(u2+t3) >*/
b[je + j] = si1 * (t2 - u3) + co1 * (u2 + t3);
/*< a(jh+j) = co2*(t2+u3) - si2*(u2-t3) >*/
a[jh + j] = co2 * (t2 + u3) - si2 * (u2 - t3);
/*< b(jh+j) = si2*(t2+u3) + co2*(u2-t3) >*/
b[jh + j] = si2 * (t2 + u3) + co2 * (u2 - t3);
/* ---------------------- */
/*< aji = a(ji+j) >*/
aji = a[ji + j];
/*< t1 = ajf + aji >*/
t1 = ajf + aji;
/*< ajg = a(jg+j) >*/
ajg = a[jg + j];
/*< t2 = ajg - 0.5 * t1 >*/
t2 = ajg - t1 * (float).5;
/*< t3 = c1 * ( ajf - aji ) >*/
t3 = c1 * (ajf - aji);
/*< t1 = ajg + t1 >*/
t1 = ajg + t1;
/*< a(jg+j) = ajc >*/
a[jg + j] = ajc;
/*< bji = b(ji+j) >*/
bji = b[ji + j];
/*< u1 = bjf + bji >*/
u1 = bjf + bji;
/*< bjg = b(jg+j) >*/
bjg = b[jg + j];
/*< u2 = bjg - 0.5 * u1 >*/
u2 = bjg - u1 * (float).5;
/*< u3 = c1 * ( bjf - bji ) >*/
u3 = c1 * (bjf - bji);
/*< u1 = bjg + u1 >*/
u1 = bjg + u1;
/*< b(jg+j) = bjc >*/
b[jg + j] = bjc;
/*< a(jc+j) = t1 >*/
a[jc + j] = t1;
/*< b(jc+j) = u1 >*/
b[jc + j] = u1;
/*< a(jf+j) = co1*(t2-u3) - si1*(u2+t3) >*/
a[jf + j] = co1 * (t2 - u3) - si1 * (u2 + t3);
/*< b(jf+j) = si1*(t2-u3) + co1*(u2+t3) >*/
b[jf + j] = si1 * (t2 - u3) + co1 * (u2 + t3);
/*< a(ji+j) = co2*(t2+u3) - si2*(u2-t3) >*/
a[ji + j] = co2 * (t2 + u3) - si2 * (u2 - t3);
/*< b(ji+j) = si2*(t2+u3) + co2*(u2-t3) >*/
b[ji + j] = si2 * (t2 + u3) + co2 * (u2 - t3);
/*< j = j + jump >*/
j += *jump;
/*< 440 continue >*/
/* L440: */
}
/* -----(end of loop across transforms) */
/*< ja = ja + jstepx >*/
ja += jstepx;
/*< if (ja.lt.istart) ja = ja + ninc >*/
if (ja < istart) {
ja += ninc;
}
/*< 445 continue >*/
/* L445: */
}
/*< 450 continue >*/
/* L450: */
}
/*< 460 continue >*/
/* L460: */
}
/* -----( end of double loop for this k ) */
/*< kk = kk + 2*la >*/
kk += la << 1;
/*< 470 continue >*/
/* L470: */
}
/* -----( end of loop over values of k ) */
/*< la = 3*la >*/
la *= 3;
/*< 480 continue >*/
/* L480: */
}
/* -----( end of loop on type II radix-3 passes ) */
/* -----( nvex transforms completed) */
/*< 490 continue >*/
L490:
/*< istart = istart + nvex * jump >*/
istart += nvex * *jump;
/*< 500 continue >*/
/* L500: */
}
/* -----( end of loop on blocks of transforms ) */
/*< return >*/
return 0;
/*< end >*/
} /* gpfa3f_ */
/* Subroutine */ int decode_(integer *ipitv, integer *irms,
integer *irc, integer *voice, integer *pitch, real *rms, real *rc,
struct lpc10_decoder_state *st)
{
/* Initialized data */
logical *first;
static integer ethrs = 2048;
static integer ethrs1 = 128;
static integer ethrs2 = 1024;
static integer ethrs3 = 2048;
static integer ivtab[32] = { 24960,24960,24960,24960,25480,25480,25483,
25480,16640,1560,1560,1560,16640,1816,1563,1560,24960,24960,24859,
24856,26001,25881,25915,25913,1560,1560,7800,3640,1561,1561,3643,
3641 };
static real corth[32] /* was [4][8] */ = { 32767.f,10.f,5.f,0.f,
32767.f,8.f,4.f,0.f,32.f,6.4f,3.2f,0.f,32.f,6.4f,3.2f,0.f,32.f,
11.2f,6.4f,0.f,32.f,11.2f,6.4f,0.f,16.f,5.6f,3.2f,0.f,16.f,5.6f,
3.2f,0.f };
static integer detau[128] = { 0,0,0,3,0,3,3,31,0,3,3,21,3,3,29,30,0,3,3,
20,3,25,27,26,3,23,58,22,3,24,28,3,0,3,3,3,3,39,33,32,3,37,35,36,
3,38,34,3,3,42,46,44,50,40,48,3,54,3,56,3,52,3,3,1,0,3,3,108,3,78,
100,104,3,84,92,88,156,80,96,3,3,74,70,72,66,76,68,3,62,3,60,3,64,
3,3,1,3,116,132,112,148,152,3,3,140,3,136,3,144,3,3,1,124,120,128,
3,3,3,3,1,3,3,3,1,3,1,1,1 };
static integer rmst[64] = { 1024,936,856,784,718,656,600,550,502,460,420,
384,352,328,294,270,246,226,206,188,172,158,144,132,120,110,102,
92,84,78,70,64,60,54,50,46,42,38,34,32,30,26,24,22,20,18,17,16,15,
14,13,12,11,10,9,8,7,6,5,4,3,2,1,0 };
static integer detab7[32] = { 4,11,18,25,32,39,46,53,60,66,72,77,82,87,92,
96,101,104,108,111,114,115,117,119,121,122,123,124,125,126,127,
127 };
static real descl[8] = { .6953f,.625f,.5781f,.5469f,.5312f,.5391f,.4688f,
.3828f };
integer *ivp2h;
static integer deadd[8] = { 1152,-2816,-1536,-3584,-1280,-2432,768,-1920 }
;
static integer qb[8] = { 511,511,1023,1023,1023,1023,2047,4095 };
static integer nbit[10] = { 8,8,5,5,4,4,4,4,3,2 };
static integer zrc[10] = { 0,0,0,0,0,3,0,2,0,0 };
static integer bit[5] = { 2,4,8,16,32 };
integer *iovoic;
integer *iavgp;
integer *iptold;
integer *erate;
integer *drc;
integer *dpit;
integer *drms;
/* System generated locals */
integer i__1, i__2;
/* Builtin functions */
integer pow_ii(integer *, integer *);
/* Local variables */
extern /* Subroutine */ int ham84_(integer *, integer *, integer *);
integer ipit, iout, i__, icorf, index, ivoic, ixcor, i1, i2, i4;
extern integer median_(integer *, integer *, integer *);
integer ishift, errcnt, lsb;
/* $Log: decode_.c,v $
/* Revision 1.1 2004/05/04 11:16:42 csoutheren
/* Initial version
/*
/* Revision 1.2 2002/02/15 03:57:55 yurik
/* Warnings removed during compilation, patch courtesy of Jehan Bing, [email protected]
/*
/* Revision 1.1 2000/06/05 04:45:12 robertj
/* Added LPC-10 2400bps codec
/*
* Revision 1.2 1996/08/20 20:22:39 jaf
* Removed all static local variables that were SAVE'd in the Fortran
* code, and put them in struct lpc10_decoder_state that is passed as an
* argument.
*
* Removed init function, since all initialization is now done in
* init_lpc10_decoder_state().
*
* Revision 1.1 1996/08/19 22:32:38 jaf
* Initial revision
* */
/* Revision 1.3 1996/03/29 22:03:47 jaf */
/* Removed definitions for any constants that were no longer used. */
/* Revision 1.2 1996/03/26 19:34:33 jaf */
/* Added comments indicating which constants are not needed in an */
/* application that uses the LPC-10 coder. */
/* Revision 1.1 1996/02/07 14:43:51 jaf */
/* Initial revision */
/* LPC Configuration parameters: */
/* Frame size, Prediction order, Pitch period */
/* Arguments */
/* $Log: decode_.c,v $
/* Revision 1.1 2004/05/04 11:16:42 csoutheren
/* Initial version
/*
/* Revision 1.2 2002/02/15 03:57:55 yurik
/* Warnings removed during compilation, patch courtesy of Jehan Bing, [email protected]
/*
/* Revision 1.1 2000/06/05 04:45:12 robertj
/* Added LPC-10 2400bps codec
/*
* Revision 1.2 1996/08/20 20:22:39 jaf
* Removed all static local variables that were SAVE'd in the Fortran
* code, and put them in struct lpc10_decoder_state that is passed as an
* argument.
*
* Removed init function, since all initialization is now done in
* init_lpc10_decoder_state().
*
* Revision 1.1 1996/08/19 22:32:38 jaf
* Initial revision
* */
/* Revision 1.3 1996/03/29 22:05:55 jaf */
/* Commented out the common block variables that are not needed by the */
/* embedded version. */
/* Revision 1.2 1996/03/26 19:34:50 jaf */
/* Added comments indicating which constants are not needed in an */
/* application that uses the LPC-10 coder. */
/* Revision 1.1 1996/02/07 14:44:09 jaf */
/* Initial revision */
/* LPC Processing control variables: */
/* *** Read-only: initialized in setup */
/* Files for Speech, Parameter, and Bitstream Input & Output, */
/* and message and debug outputs. */
/* Here are the only files which use these variables: */
/* lpcsim.f setup.f trans.f error.f vqsetup.f */
/* Many files which use fdebug are not listed, since it is only used in */
/* those other files conditionally, to print trace statements. */
/* integer fsi, fso, fpi, fpo, fbi, fbo, pbin, fmsg, fdebug */
/* LPC order, Frame size, Quantization rate, Bits per frame, */
/* Error correction */
/* Subroutine SETUP is the only place where order is assigned a value, */
/* and that value is 10. It could increase efficiency 1% or so to */
/* declare order as a constant (i.e., a Fortran PARAMETER) instead of as
*/
/* a variable in a COMMON block, since it is used in many places in the */
/* core of the coding and decoding routines. Actually, I take that back.
*/
/* At least when compiling with f2c, the upper bound of DO loops is */
/* stored in a local variable before the DO loop begins, and then that is
*/
/* compared against on each iteration. */
/* Similarly for lframe, which is given a value of MAXFRM in SETUP. */
/* Similarly for quant, which is given a value of 2400 in SETUP. quant */
/* is used in only a few places, and never in the core coding and */
/* decoding routines, so it could be eliminated entirely. */
/* nbits is similar to quant, and is given a value of 54 in SETUP. */
/* corrp is given a value of .TRUE. in SETUP, and is only used in the */
/* subroutines ENCODE and DECODE. It doesn't affect the speed of the */
/* coder significantly whether it is .TRUE. or .FALSE., or whether it is
*/
/* a constant or a variable, since it is only examined once per frame. */
/* Leaving it as a variable that is set to .TRUE. seems like a good */
/* idea, since it does enable some error-correction capability for */
/* unvoiced frames, with no change in the coding rate, and no noticeable
*/
/* quality difference in the decoded speech. */
/* integer quant, nbits */
/* *** Read/write: variables for debugging, not needed for LPC algorithm
*/
/* Current frame, Unstable frames, Output clip count, Max onset buffer,
*/
/* Debug listing detail level, Line count on listing page */
/* nframe is not needed for an embedded LPC10 at all. */
/* nunsfm is initialized to 0 in SETUP, and incremented in subroutine */
/* ERROR, which is only called from RCCHK. When LPC10 is embedded into */
/* an application, I would recommend removing the call to ERROR in RCCHK,
*/
/* and remove ERROR and nunsfm completely. */
/* iclip is initialized to 0 in SETUP, and incremented in entry SWRITE in
*/
/* sread.f. When LPC10 is embedded into an application, one might want */
/* to cause it to be incremented in a routine that takes the output of */
/* SYNTHS and sends it to an audio device. It could be optionally */
/* displayed, for those that might want to know what it is. */
/* maxosp is never initialized to 0 in SETUP, although it probably should
*/
/* be, and it is updated in subroutine ANALYS. I doubt that its value */
/* would be of much interest to an application in which LPC10 is */
/* embedded. */
/* listl and lincnt are not needed for an embedded LPC10 at all. */
/* integer nframe, nunsfm, iclip, maxosp, listl, lincnt */
/* common /contrl/ fsi, fso, fpi, fpo, fbi, fbo, pbin, fmsg, fdebug */
/* common /contrl/ quant, nbits */
/* common /contrl/ nframe, nunsfm, iclip, maxosp, listl, lincnt */
/* Function return value definitions */
/* Parameters/constants */
/* The variables below that are not Fortran PARAMETER's are */
/* initialized with DATA statements, and then never modified. */
/* The following are used regardless of CORRP's value. */
/* DETAU, NBIT, QB, DEADD, DETAB7, RMST, DESCL */
/* The following are used only if CORRP is .TRUE. */
/* ETHRS, ETHRS1, ETHRS2, ETHRS3, IVTAB, BIT, CORTH, ZRC */
/* Local variables that need not be saved */
/* The following are used regardless of CORRP's value */
/* The following are used only if CORRP is .TRUE. */
/* Local state */
/* The following are used regardless of CORRP's value */
/* The following are used only if CORRP is .TRUE. */
/* I am guessing the initial values for IVP2H, IOVOIC, DRC, DPIT, */
/* and DRMS. They should be checked to see if they are reasonable.
*/
/* I'm also guessing for ERATE, but I think 0 is the right initial
*/
/* value. */
/* Parameter adjustments */
if (irc) {
--irc;
}
if (voice) {
--voice;
}
if (rc) {
--rc;
}
/* Function Body */
iptold = &(st->iptold);
first = &(st->first);
ivp2h = &(st->ivp2h);
iovoic = &(st->iovoic);
iavgp = &(st->iavgp);
erate = &(st->erate);
drc = &(st->drc[0]);
dpit = &(st->dpit[0]);
drms = &(st->drms[0]);
/* DATA statements for "constants" defined above. */
/* IF (LISTL.GE.3) WRITE(FDEBUG,800) IPITV,IRMS,(IRC(J),J=1,ORDER) */
/* 800 FORMAT(1X,' <<ERRCOR IN>>',T32,6X,I6,I5,T50,10I8) */
/* If no error correction, do pitch and voicing then jump to decode */
i4 = detau[*ipitv];
if (! contrl_1.corrp) {
voice[1] = 1;
voice[2] = 1;
if (*ipitv <= 1) {
voice[1] = 0;
}
if (*ipitv == 0 || *ipitv == 2) {
voice[2] = 0;
}
*pitch = i4;
if (*pitch <= 4) {
*pitch = *iptold;
}
if (voice[1] == 1 && voice[2] == 1) {
*iptold = *pitch;
}
if (voice[1] != voice[2]) {
*pitch = *iptold;
}
goto L900;
}
/* Do error correction pitch and voicing */
if (i4 > 4) {
dpit[0] = i4;
ivoic = 2;
*iavgp = (*iavgp * 15 + i4 + 8) / 16;
} else {
ivoic = i4;
dpit[0] = *iavgp;
}
drms[0] = *irms;
i__1 = contrl_1.order;
for (i__ = 1; i__ <= i__1; ++i__) {
drc[i__ * 3 - 3] = irc[i__];
}
/* Determine index to IVTAB from V/UV decision */
/* If error rate is high then use alternate table */
index = (*ivp2h << 4) + (*iovoic << 2) + ivoic + 1;
i1 = ivtab[index - 1];
ipit = i1 & 3;
icorf = i1 / 8;
if (*erate < ethrs) {
icorf /= 64;
}
/* Determine error rate: 4=high 1=low */
ixcor = 4;
if (*erate < ethrs3) {
ixcor = 3;
}
if (*erate < ethrs2) {
ixcor = 2;
}
if (*erate < ethrs1) {
ixcor = 1;
}
/* Voice/unvoice decision determined from bits 0 and 1 of IVTAB */
voice[1] = icorf / 2 & 1;
voice[2] = icorf & 1;
/* Skip decoding on first frame because present data not yet available */
if (*first) {
*first = FALSE_;
/* Assign PITCH a "default" value on the first call, since */
/* otherwise it would be left uninitialized. The two lines
*/
/* below were copied from above, since it seemed like a */
/* reasonable thing to do for the first call. */
*pitch = i4;
if (*pitch <= 4) {
*pitch = *iptold;
}
goto L500;
}
/* If bit 4 of ICORF is set then correct RMS and RC(1) - RC(4). */
/* Determine error rate and correct errors using a Hamming 8,4 code */
/* during transition or unvoiced frame. If IOUT is negative, */
/* more than 1 error occurred, use previous frame's parameters. */
if ((icorf & bit[3]) != 0) {
errcnt = 0;
lsb = drms[1] & 1;
index = (drc[22] << 4) + drms[1] / 2;
ham84_(&index, &iout, &errcnt);
drms[1] = drms[2];
if (iout >= 0) {
drms[1] = (iout << 1) + lsb;
}
for (i__ = 1; i__ <= 4; ++i__) {
if (i__ == 1) {
i1 = ((drc[25] & 7) << 1) + (drc[28] & 1);
} else {
i1 = drc[(9 - i__) * 3 - 2] & 15;
}
i2 = drc[(5 - i__) * 3 - 2] & 31;
lsb = i2 & 1;
index = (i1 << 4) + i2 / 2;
ham84_(&index, &iout, &errcnt);
if (iout >= 0) {
iout = (iout << 1) + lsb;
if ((iout & 16) == 16) {
iout += -32;
}
} else {
iout = drc[(5 - i__) * 3 - 1];
}
drc[(5 - i__) * 3 - 2] = iout;
}
/* Determine error rate */
*erate = (integer)(*erate * .96875f + errcnt * 102);
}
/* Get unsmoothed RMS, RC's, and PITCH */
*irms = drms[1];
i__1 = contrl_1.order;
for (i__ = 1; i__ <= i__1; ++i__) {
irc[i__] = drc[i__ * 3 - 2];
}
if (ipit == 1) {
dpit[1] = dpit[2];
}
if (ipit == 3) {
dpit[1] = dpit[0];
}
*pitch = dpit[1];
/* If bit 2 of ICORF is set then smooth RMS and RC's, */
if ((icorf & bit[1]) != 0) {
if ((i__1 = drms[1] - drms[0], (real) abs(i__1)) >= corth[ixcor + 3]
&& (i__2 = drms[1] - drms[2], (real) abs(i__2)) >= corth[
ixcor + 3]) {
*irms = median_(&drms[2], &drms[1], drms);
}
for (i__ = 1; i__ <= 6; ++i__) {
if ((i__1 = drc[i__ * 3 - 2] - drc[i__ * 3 - 3], (real) abs(i__1))
>= corth[ixcor + (i__ + (2 << 2)) - 5] && (i__2 = drc[i__ *
3 - 2] - drc[i__ * 3 - 1], (real) abs(i__2)) >= corth[
ixcor + (i__ + (2 << 2)) - 5]) {
irc[i__] = median_(&drc[i__ * 3 - 1], &drc[i__ * 3 - 2], &drc[
i__ * 3 - 3]);
}
}
}
/* If bit 3 of ICORF is set then smooth pitch */
if ((icorf & bit[2]) != 0) {
if ((i__1 = dpit[1] - dpit[0], (real) abs(i__1)) >= corth[ixcor - 1]
&& (i__2 = dpit[1] - dpit[2], (real) abs(i__2)) >= corth[
ixcor - 1]) {
*pitch = median_(&dpit[2], &dpit[1], dpit);
}
}
/* If bit 5 of ICORF is set then RC(5) - RC(10) are loaded with */
/* values so that after quantization bias is removed in decode */
/* the values will be zero. */
L500:
if ((icorf & bit[4]) != 0) {
i__1 = contrl_1.order;
for (i__ = 5; i__ <= i__1; ++i__) {
irc[i__] = zrc[i__ - 1];
}
}
/* House keeping - one frame delay */
*iovoic = ivoic;
*ivp2h = voice[2];
dpit[2] = dpit[1];
dpit[1] = dpit[0];
drms[2] = drms[1];
drms[1] = drms[0];
i__1 = contrl_1.order;
for (i__ = 1; i__ <= i__1; ++i__) {
drc[i__ * 3 - 1] = drc[i__ * 3 - 2];
drc[i__ * 3 - 2] = drc[i__ * 3 - 3];
}
L900:
/* IF (LISTL.GE.3)WRITE(FDEBUG,801)VOICE,PITCH,IRMS,(IRC(J),J=1,ORDER) */
/* 801 FORMAT(1X,'<<ERRCOR OUT>>',T32,2I3,I6,I5,T50,10I8) */
/* Decode RMS */
*irms = rmst[(31 - *irms) * 2];
/* Decode RC(1) and RC(2) from log-area-ratios */
/* Protect from illegal coded value (-16) caused by bit errors */
for (i__ = 1; i__ <= 2; ++i__) {
i2 = irc[i__];
i1 = 0;
if (i2 < 0) {
i1 = 1;
i2 = -i2;
if (i2 > 15) {
i2 = 0;
}
}
i2 = detab7[i2 * 2];
if (i1 == 1) {
i2 = -i2;
}
ishift = 15 - nbit[i__ - 1];
irc[i__] = i2 * pow_ii(&c__2, &ishift);
}
/* Decode RC(3)-RC(10) to sign plus 14 bits */
i__1 = contrl_1.order;
for (i__ = 3; i__ <= i__1; ++i__) {
i2 = irc[i__];
ishift = 15 - nbit[i__ - 1];
i2 *= pow_ii(&c__2, &ishift);
i2 += qb[i__ - 3];
irc[i__] = (integer)(i2 * descl[i__ - 3] + deadd[i__ - 3]);
}
/* IF (LISTL.GE.3) WRITE(FDEBUG,811) IRMS, (IRC(I),I=1,ORDER) */
/* 811 FORMAT(1X,'<<DECODE OUT>>',T45,I4,1X,10I8) */
/* Scale RMS and RC's to reals */
*rms = (real) (*irms);
i__1 = contrl_1.order;
for (i__ = 1; i__ <= i__1; ++i__) {
rc[i__] = irc[i__] / 16384.f;
}
return 0;
} /* decode_ */
int lpc10_internal_encode(int32_t * voice, int32_t * pitch, float *rms,
float *rc, int32_t * ipitch, int32_t * irms,
int32_t * irc)
{
/* Initialized data */
static int32_t enctab[16] =
{ 0, 7, 11, 12, 13, 10, 6, 1, 14, 9, 5, 2, 3, 4, 8, 15 };
static int32_t entau[60] =
{ 19, 11, 27, 25, 29, 21, 23, 22, 30, 14, 15, 7, 39, 38, 46,
42, 43, 41, 45, 37, 53, 49, 51, 50, 54, 52, 60, 56, 58, 26, 90,
88, 92, 84, 86, 82, 83,
81, 85, 69, 77, 73, 75, 74, 78, 70, 71, 67, 99, 97, 113, 112,
114, 98, 106, 104, 108,
100, 101, 76
};
static int32_t enadd[8] =
{ 1920, -768, 2432, 1280, 3584, 1536, 2816, -1152 };
static float enscl[8] =
{ .0204f, .0167f, .0145f, .0147f, .0143f, .0135f, .0125f,
.0112f
};
static int32_t enbits[8] = { 6, 5, 4, 4, 4, 4, 3, 3 };
static int32_t entab6[64] =
{ 0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 1, 1, 1, 2, 2, 2, 2, 2, 2, 2, 3, 3,
3, 3, 3, 3, 3, 4, 4, 4, 4, 4, 4, 4, 5, 5, 5, 5, 5, 6, 6, 6, 6,
6, 7, 7, 7, 7, 7, 8, 8, 8, 8, 9, 9,
9, 10, 10, 11, 11, 12, 13, 14, 15
};
static int32_t rmst[64] =
{ 1024, 936, 856, 784, 718, 656, 600, 550, 502, 460, 420,
384, 352, 328, 294, 270, 246, 226, 206, 188, 172, 158, 144, 132,
120, 110, 102,
92, 84, 78, 70, 64, 60, 54, 50, 46, 42, 38, 34, 32, 30, 26, 24,
22, 20, 18, 17, 16, 15,
14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0
};
/* System generated locals */
int32_t i__1, i__2;
/* Local variables */
int32_t idel, nbit, i__, j, i2, i3, mrk;
/* $Log$
* Revision 1.15 2004/06/26 03:50:14 markster
* Merge source cleanups (bug #1911)
*
* Revision 1.14 2003/02/12 13:59:15 matteo
* mer feb 12 14:56:57 CET 2003
*
* Revision 1.1.1.1 2003/02/12 13:59:15 matteo
* mer feb 12 14:56:57 CET 2003
*
* Revision 1.2 2000/01/05 08:20:39 markster
* Some OSS fixes and a few lpc changes to make it actually work
*
* Revision 1.1 1996/08/19 22:32:21 jaf
* Initial revision
* */
/* Revision 1.3 1996/03/29 22:03:47 jaf */
/* Removed definitions for any constants that were no longer used. */
/* Revision 1.2 1996/03/26 19:34:33 jaf */
/* Added comments indicating which constants are not needed in an */
/* application that uses the LPC-10 coder. */
/* Revision 1.1 1996/02/07 14:43:51 jaf */
/* Initial revision */
/* LPC Configuration parameters: */
/* Frame size, Prediction order, Pitch period */
/* Arguments */
/* $Log$
* Revision 1.15 2004/06/26 03:50:14 markster
* Merge source cleanups (bug #1911)
*
* Revision 1.14 2003/02/12 13:59:15 matteo
* mer feb 12 14:56:57 CET 2003
*
* Revision 1.1.1.1 2003/02/12 13:59:15 matteo
* mer feb 12 14:56:57 CET 2003
*
* Revision 1.2 2000/01/05 08:20:39 markster
* Some OSS fixes and a few lpc changes to make it actually work
*
* Revision 1.1 1996/08/19 22:32:21 jaf
* Initial revision
* */
/* Revision 1.3 1996/03/29 22:05:55 jaf */
/* Commented out the common block variables that are not needed by the */
/* embedded version. */
/* Revision 1.2 1996/03/26 19:34:50 jaf */
/* Added comments indicating which constants are not needed in an */
/* application that uses the LPC-10 coder. */
/* Revision 1.1 1996/02/07 14:44:09 jaf */
/* Initial revision */
/* LPC Processing control variables: */
/* *** Read-only: initialized in setup */
/* Files for Speech, Parameter, and Bitstream Input & Output, */
/* and message and debug outputs. */
/* Here are the only files which use these variables: */
/* lpcsim.f setup.f trans.f error.f vqsetup.f */
/* Many files which use fdebug are not listed, since it is only used in */
/* those other files conditionally, to print trace statements. */
/* int32_t fsi, fso, fpi, fpo, fbi, fbo, pbin, fmsg, fdebug */
/* LPC order, Frame size, Quantization rate, Bits per frame, */
/* Error correction */
/* Subroutine SETUP is the only place where order is assigned a value, */
/* and that value is 10. It could increase efficiency 1% or so to */
/* declare order as a constant (i.e., a Fortran PARAMETER) instead of as
*/
/* a variable in a COMMON block, since it is used in many places in the */
/* core of the coding and decoding routines. Actually, I take that back.
*/
/* At least when compiling with f2c, the upper bound of DO loops is */
/* stored in a local variable before the DO loop begins, and then that is
*/
/* compared against on each iteration. */
/* Similarly for lframe, which is given a value of MAXFRM in SETUP. */
/* Similarly for quant, which is given a value of 2400 in SETUP. quant */
/* is used in only a few places, and never in the core coding and */
/* decoding routines, so it could be eliminated entirely. */
/* nbits is similar to quant, and is given a value of 54 in SETUP. */
/* corrp is given a value of .TRUE. in SETUP, and is only used in the */
/* subroutines ENCODE and DECODE. It doesn't affect the speed of the */
/* coder significantly whether it is .TRUE. or .FALSE., or whether it is
*/
/* a constant or a variable, since it is only examined once per frame. */
/* Leaving it as a variable that is set to .TRUE. seems like a good */
/* idea, since it does enable some error-correction capability for */
/* unvoiced frames, with no change in the coding rate, and no noticeable
*/
/* quality difference in the decoded speech. */
/* int32_t quant, nbits */
/* *** Read/write: variables for debugging, not needed for LPC algorithm
*/
/* Current frame, Unstable frames, Output clip count, Max onset buffer,
*/
/* Debug listing detail level, Line count on listing page */
/* nframe is not needed for an embedded LPC10 at all. */
/* nunsfm is initialized to 0 in SETUP, and incremented in subroutine */
/* ERROR, which is only called from RCCHK. When LPC10 is embedded into */
/* an application, I would recommend removing the call to ERROR in RCCHK,
*/
/* and remove ERROR and nunsfm completely. */
/* iclip is initialized to 0 in SETUP, and incremented in entry SWRITE in
*/
/* sread.f. When LPC10 is embedded into an application, one might want */
/* to cause it to be incremented in a routine that takes the output of */
/* SYNTHS and sends it to an audio device. It could be optionally */
/* displayed, for those that might want to know what it is. */
/* maxosp is never initialized to 0 in SETUP, although it probably should
*/
/* be, and it is updated in subroutine ANALYS. I doubt that its value */
/* would be of much interest to an application in which LPC10 is */
/* embedded. */
/* listl and lincnt are not needed for an embedded LPC10 at all. */
/* int32_t nframe, nunsfm, iclip, maxosp, listl, lincnt */
/* common /contrl/ fsi, fso, fpi, fpo, fbi, fbo, pbin, fmsg, fdebug */
/* common /contrl/ quant, nbits */
/* common /contrl/ nframe, nunsfm, iclip, maxosp, listl, lincnt */
/* Parameters/constants */
/* These arrays are not Fortran PARAMETER's, but they are defined */
/* by DATA statements below, and their contents are never altered.
*/
/* Local variables that need not be saved */
/* Parameter adjustments */
--irc;
--rc;
--voice;
/* Function Body */
/* Scale RMS and RC's to int32_ts */
*irms = (int32_t) * rms;
i__1 = lpc10_contrl_ctx.order;
for (i__ = 1; i__ <= i__1; ++i__) {
irc[i__] = (int32_t) (rc[i__] * 32768.f);
}
/* IF(LISTL.GE.3)WRITE(FDEBUG,800)VOICE,PITCH,IRMS,(IRC(I),I=1,ORDER) */
/* 800 FORMAT(1X,/,' <<ENCODE IN>>',T32,2I3,I6,I5,T50,10I8) */
/* Encode pitch and voicing */
if (voice[1] != 0 && voice[2] != 0) {
*ipitch = entau[*pitch - 1];
} else {
if (lpc10_contrl_ctx.corrp) {
*ipitch = 0;
if (voice[1] != voice[2]) {
*ipitch = 127;
}
} else {
*ipitch = (voice[1] << 1) + voice[2];
}
}
/* Encode RMS by binary table search */
j = 32;
idel = 16;
*irms = min(*irms, 1023);
while (idel > 0) {
if (*irms > rmst[j - 1]) {
j -= idel;
}
if (*irms < rmst[j - 1]) {
j += idel;
}
idel /= 2;
}
if (*irms > rmst[j - 1]) {
--j;
}
*irms = 31 - j / 2;
/* Encode RC(1) and (2) as log-area-ratios */
for (i__ = 1; i__ <= 2; ++i__) {
i2 = irc[i__];
mrk = 0;
if (i2 < 0) {
i2 = -i2;
mrk = 1;
}
i2 /= 512;
i2 = min(i2, 63);
i2 = entab6[i2];
if (mrk != 0) {
i2 = -i2;
}
irc[i__] = i2;
}
/* Encode RC(3) - (10) linearly, remove bias then scale */
i__1 = lpc10_contrl_ctx.order;
for (i__ = 3; i__ <= i__1; ++i__) {
i2 = irc[i__] / 2;
i2 = (int32_t) ((i2 +
enadd[lpc10_contrl_ctx.order + 1 - i__ -
1]) * enscl[lpc10_contrl_ctx.order + 1 -
i__ - 1]);
/* Computing MIN */
i__2 = max(i2, -127);
i2 = min(i__2, 127);
nbit = enbits[lpc10_contrl_ctx.order + 1 - i__ - 1];
i3 = 0;
if (i2 < 0) {
i3 = -1;
}
i2 /= pow_ii(&c__2, &nbit);
if (i3 == -1) {
--i2;
}
irc[i__] = i2;
}
/* Protect the most significant bits of the most */
/* important parameters during non-voiced frames. */
/* RC(1) - RC(4) are protected using 20 parity bits */
/* replacing RC(5) - RC(10). */
if (lpc10_contrl_ctx.corrp) {
if (*ipitch == 0 || *ipitch == 127) {
irc[5] = enctab[(irc[1] & 30) / 2];
irc[6] = enctab[(irc[2] & 30) / 2];
irc[7] = enctab[(irc[3] & 30) / 2];
irc[8] = enctab[(*irms & 30) / 2];
irc[9] = enctab[(irc[4] & 30) / 2] / 2;
irc[10] = enctab[(irc[4] & 30) / 2] & 1;
}
}
/* IF(LISTL.GE.3)WRITE(FDEBUG,801)VOICE,IPITCH,IRMS,(IRC(J),J=1,ORDER) */
/* 801 FORMAT(1X,'<<ENCODE OUT>>',T32,2I3,I6,I5,T50,10I8) */
return 0;
} /* lpc10_internal_encode_ */
/* Subroutine */ int sstevd_(char *jobz, integer *n, real *d, real *e, real *
z, integer *ldz, real *work, integer *lwork, integer *iwork, integer *
liwork, integer *info)
{
/* -- LAPACK driver 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
=======
SSTEVD computes all eigenvalues and, optionally, eigenvectors of a
real symmetric tridiagonal matrix. If eigenvectors are desired, it
uses a divide and conquer algorithm.
The divide and conquer algorithm makes very mild assumptions about
floating point arithmetic. It will work on machines with a guard
digit in add/subtract, or on those binary machines without guard
digits which subtract like the Cray X-MP, Cray Y-MP, Cray C-90, or
Cray-2. It could conceivably fail on hexadecimal or decimal machines
without guard digits, but we know of none.
Arguments
=========
JOBZ (input) CHARACTER*1
= 'N': Compute eigenvalues only;
= 'V': Compute eigenvalues and eigenvectors.
N (input) INTEGER
The order of the matrix. N >= 0.
D (input/output) REAL array, dimension (N)
On entry, the n diagonal elements of the tridiagonal matrix
A.
On exit, if INFO = 0, the eigenvalues in ascending order.
E (input/output) REAL array, dimension (N)
On entry, the (n-1) subdiagonal elements of the tridiagonal
matrix A, stored in elements 1 to N-1 of E; E(N) need not
be set, but is used by the routine.
On exit, the contents of E are destroyed.
Z (output) REAL array, dimension (LDZ, N)
If JOBZ = 'V', then if INFO = 0, Z contains the orthonormal
eigenvectors of the matrix A, with the i-th column of Z
holding the eigenvector associated with D(i).
If JOBZ = 'N', then Z is not referenced.
LDZ (input) INTEGER
The leading dimension of the array Z. LDZ >= 1, and if
JOBZ = 'V', LDZ >= max(1,N).
WORK (workspace/output) REAL array,
dimension (LWORK)
On exit, if LWORK > 0, WORK(1) returns the optimal LWORK.
LWORK (input) INTEGER
The dimension of the array WORK.
If JOBZ = 'N' or N <= 1 then LWORK must be at least 1.
If JOBZ = 'V' and N > 1 then LWORK must be at least
( 1 + 3*N + 2*N*lg N + 2*N**2 ),
where lg( N ) = smallest integer k such
that 2**k >= N.
IWORK (workspace/output) INTEGER array, dimension (LIWORK)
On exit, if LIWORK > 0, IWORK(1) returns the optimal LIWORK.
LIWORK (input) INTEGER
The dimension of the array IWORK.
If JOBZ = 'N' or N <= 1 then LIWORK must be at least 1.
If JOBZ = 'V' and N > 1 then LIWORK must be at least 2+5*N.
INFO (output) INTEGER
= 0: successful exit
< 0: if INFO = -i, the i-th argument had an illegal value
> 0: if INFO = i, the algorithm failed to converge; i
off-diagonal elements of E did not converge to zero.
=====================================================================
Test the input parameters.
Parameter adjustments
Function Body */
/* Table of constant values */
static integer c__2 = 2;
static integer c__1 = 1;
/* System generated locals */
integer z_dim1, z_offset, i__1;
real r__1;
/* Builtin functions */
double log(doublereal);
integer pow_ii(integer *, integer *);
double sqrt(doublereal);
/* Local variables */
static real rmin, rmax, tnrm, sigma;
extern logical lsame_(char *, char *);
extern /* Subroutine */ int sscal_(integer *, real *, real *, integer *);
static integer lwmin;
static logical wantz;
static integer iscale;
extern doublereal slamch_(char *);
static real safmin;
extern /* Subroutine */ int xerbla_(char *, integer *);
static real bignum;
extern /* Subroutine */ int sstedc_(char *, integer *, real *, real *,
real *, integer *, real *, integer *, integer *, integer *,
integer *);
static integer liwmin;
extern doublereal slanst_(char *, integer *, real *, real *);
extern /* Subroutine */ int ssterf_(integer *, real *, real *, integer *);
static real smlnum;
static integer lgn;
static real eps;
#define D(I) d[(I)-1]
#define E(I) e[(I)-1]
#define WORK(I) work[(I)-1]
#define IWORK(I) iwork[(I)-1]
#define Z(I,J) z[(I)-1 + ((J)-1)* ( *ldz)]
wantz = lsame_(jobz, "V");
*info = 0;
liwmin = 1;
lwmin = 1;
if (! (wantz || lsame_(jobz, "N"))) {
*info = -1;
} else if (*n < 0) {
*info = -2;
} else if (*ldz < 1 || wantz && *ldz < *n) {
*info = -6;
} else if (*n > 1 && wantz) {
lgn = (integer) (log((real) (*n)) / log(2.f));
if (pow_ii(&c__2, &lgn) < *n) {
++lgn;
}
if (pow_ii(&c__2, &lgn) < *n) {
++lgn;
}
/* Computing 2nd power */
i__1 = *n;
lwmin = *n * 3 + 1 + (*n << 1) * lgn + (i__1 * i__1 << 1);
liwmin = *n * 5 + 2;
if (*lwork < lwmin) {
*info = -8;
} else if (*liwork < liwmin) {
*info = -10;
}
} else if (*lwork < 1) {
*info = -8;
} else if (*liwork < 1) {
*info = -10;
}
if (*info != 0) {
i__1 = -(*info);
xerbla_("SSTEVD", &i__1);
goto L10;
}
/* Quick return if possible */
if (*n == 0) {
goto L10;
}
if (*n == 1) {
if (wantz) {
Z(1,1) = 1.f;
}
goto L10;
}
/* Get machine constants. */
safmin = slamch_("Safe minimum");
eps = slamch_("Precision");
smlnum = safmin / eps;
bignum = 1.f / smlnum;
rmin = sqrt(smlnum);
rmax = sqrt(bignum);
/* Scale matrix to allowable range, if necessary. */
iscale = 0;
tnrm = slanst_("M", n, &D(1), &E(1));
if (tnrm > 0.f && tnrm < rmin) {
iscale = 1;
sigma = rmin / tnrm;
} else if (tnrm > rmax) {
iscale = 1;
sigma = rmax / tnrm;
}
if (iscale == 1) {
sscal_(n, &sigma, &D(1), &c__1);
i__1 = *n - 1;
sscal_(&i__1, &sigma, &E(1), &c__1);
}
/* For eigenvalues only, call SSTERF. For eigenvalues and
eigenvectors, call SSTEDC. */
if (! wantz) {
ssterf_(n, &D(1), &E(1), info);
} else {
sstedc_("I", n, &D(1), &E(1), &Z(1,1), ldz, &WORK(1), lwork, &
IWORK(1), liwork, info);
}
/* If matrix was scaled, then rescale eigenvalues appropriately. */
if (iscale == 1) {
r__1 = 1.f / sigma;
sscal_(n, &r__1, &D(1), &c__1);
}
L10:
if (*lwork > 0) {
WORK(1) = (real) lwmin;
}
if (*liwork > 0) {
IWORK(1) = liwmin;
}
return 0;
/* End of SSTEVD */
} /* sstevd_ */
/* Subroutine */ int schkeq_(real *thresh, integer *nout)
{
/* Format strings */
static char fmt_9999[] = "(1x,\002All tests for \002,a3,\002 routines pa"
"ssed the threshold\002)";
static char fmt_9998[] = "(\002 SGEEQU failed test with value \002,e10"
".3,\002 exceeding\002,\002 threshold \002,e10.3)";
static char fmt_9997[] = "(\002 SGBEQU failed test with value \002,e10"
".3,\002 exceeding\002,\002 threshold \002,e10.3)";
static char fmt_9996[] = "(\002 SPOEQU failed test with value \002,e10"
".3,\002 exceeding\002,\002 threshold \002,e10.3)";
static char fmt_9995[] = "(\002 SPPEQU failed test with value \002,e10"
".3,\002 exceeding\002,\002 threshold \002,e10.3)";
static char fmt_9994[] = "(\002 SPBEQU failed test with value \002,e10"
".3,\002 exceeding\002,\002 threshold \002,e10.3)";
/* System generated locals */
integer i__1, i__2, i__3, i__4, i__5, i__6, i__7, i__8;
real r__1, r__2, r__3;
/* Local variables */
real a[25] /* was [5][5] */, c__[5];
integer i__, j, m, n;
real r__[5], ab[65] /* was [13][5] */, ap[15];
integer kl;
logical ok;
integer ku;
real eps, pow[11];
integer info;
char path[3];
real norm, rpow[11], ccond, rcond, rcmin, rcmax, ratio;
real reslts[5];
/* Fortran I/O blocks */
static cilist io___25 = { 0, 0, 0, 0, 0 };
static cilist io___26 = { 0, 0, 0, fmt_9999, 0 };
static cilist io___27 = { 0, 0, 0, fmt_9998, 0 };
static cilist io___28 = { 0, 0, 0, fmt_9997, 0 };
static cilist io___29 = { 0, 0, 0, fmt_9996, 0 };
static cilist io___30 = { 0, 0, 0, fmt_9995, 0 };
static cilist io___31 = { 0, 0, 0, fmt_9994, 0 };
/* -- LAPACK test routine (version 3.1) -- */
/* Univ. of Tennessee, Univ. of California Berkeley and NAG Ltd.. */
/* November 2006 */
/* .. Scalar Arguments .. */
/* .. */
/* Purpose */
/* ======= */
/* SCHKEQ tests SGEEQU, SGBEQU, SPOEQU, SPPEQU and SPBEQU */
/* Arguments */
/* ========= */
/* THRESH (input) REAL */
/* Threshold for testing routines. Should be between 2 and 10. */
/* NOUT (input) INTEGER */
/* The unit number for output. */
/* ===================================================================== */
/* .. Parameters .. */
/* .. */
/* .. Local Scalars .. */
/* .. */
/* .. Local Arrays .. */
/* .. */
/* .. External Functions .. */
/* .. */
/* .. External Subroutines .. */
/* .. */
/* .. Intrinsic Functions .. */
/* .. */
/* .. Executable Statements .. */
s_copy(path, "Single precision", (ftnlen)1, (ftnlen)16);
s_copy(path + 1, "EQ", (ftnlen)2, (ftnlen)2);
eps = slamch_("P");
for (i__ = 1; i__ <= 5; ++i__) {
reslts[i__ - 1] = 0.f;
/* L10: */
}
for (i__ = 1; i__ <= 11; ++i__) {
i__1 = i__ - 1;
pow[i__ - 1] = pow_ri(&c_b7, &i__1);
rpow[i__ - 1] = 1.f / pow[i__ - 1];
/* L20: */
}
/* Test SGEEQU */
for (n = 0; n <= 5; ++n) {
for (m = 0; m <= 5; ++m) {
for (j = 1; j <= 5; ++j) {
for (i__ = 1; i__ <= 5; ++i__) {
if (i__ <= m && j <= n) {
i__1 = i__ + j;
a[i__ + j * 5 - 6] = pow[i__ + j] * pow_ii(&c_n1, &
i__1);
} else {
a[i__ + j * 5 - 6] = 0.f;
}
/* L30: */
}
/* L40: */
}
sgeequ_(&m, &n, a, &c__5, r__, c__, &rcond, &ccond, &norm, &info);
if (info != 0) {
reslts[0] = 1.f;
} else {
if (n != 0 && m != 0) {
/* Computing MAX */
r__2 = reslts[0], r__3 = (r__1 = (rcond - rpow[m - 1]) /
rpow[m - 1], dabs(r__1));
reslts[0] = dmax(r__2,r__3);
/* Computing MAX */
r__2 = reslts[0], r__3 = (r__1 = (ccond - rpow[n - 1]) /
rpow[n - 1], dabs(r__1));
reslts[0] = dmax(r__2,r__3);
/* Computing MAX */
r__2 = reslts[0], r__3 = (r__1 = (norm - pow[n + m]) /
pow[n + m], dabs(r__1));
reslts[0] = dmax(r__2,r__3);
i__1 = m;
for (i__ = 1; i__ <= i__1; ++i__) {
/* Computing MAX */
r__2 = reslts[0], r__3 = (r__1 = (r__[i__ - 1] - rpow[
i__ + n]) / rpow[i__ + n], dabs(r__1));
reslts[0] = dmax(r__2,r__3);
/* L50: */
}
i__1 = n;
for (j = 1; j <= i__1; ++j) {
/* Computing MAX */
r__2 = reslts[0], r__3 = (r__1 = (c__[j - 1] - pow[n
- j]) / pow[n - j], dabs(r__1));
reslts[0] = dmax(r__2,r__3);
/* L60: */
}
}
}
/* L70: */
}
/* L80: */
}
/* Test with zero rows and columns */
for (j = 1; j <= 5; ++j) {
a[j * 5 - 2] = 0.f;
/* L90: */
}
sgeequ_(&c__5, &c__5, a, &c__5, r__, c__, &rcond, &ccond, &norm, &info);
if (info != 4) {
reslts[0] = 1.f;
}
for (j = 1; j <= 5; ++j) {
a[j * 5 - 2] = 1.f;
/* L100: */
}
for (i__ = 1; i__ <= 5; ++i__) {
a[i__ + 14] = 0.f;
/* L110: */
}
sgeequ_(&c__5, &c__5, a, &c__5, r__, c__, &rcond, &ccond, &norm, &info);
if (info != 9) {
reslts[0] = 1.f;
}
reslts[0] /= eps;
/* Test SGBEQU */
for (n = 0; n <= 5; ++n) {
for (m = 0; m <= 5; ++m) {
/* Computing MAX */
i__2 = m - 1;
i__1 = max(i__2,0);
for (kl = 0; kl <= i__1; ++kl) {
/* Computing MAX */
i__3 = n - 1;
i__2 = max(i__3,0);
for (ku = 0; ku <= i__2; ++ku) {
for (j = 1; j <= 5; ++j) {
for (i__ = 1; i__ <= 13; ++i__) {
ab[i__ + j * 13 - 14] = 0.f;
/* L120: */
}
/* L130: */
}
i__3 = n;
for (j = 1; j <= i__3; ++j) {
i__4 = m;
for (i__ = 1; i__ <= i__4; ++i__) {
/* Computing MIN */
i__5 = m, i__6 = j + kl;
/* Computing MAX */
i__7 = 1, i__8 = j - ku;
if (i__ <= min(i__5,i__6) && i__ >= max(i__7,i__8)
&& j <= n) {
i__5 = i__ + j;
ab[ku + 1 + i__ - j + j * 13 - 14] = pow[i__
+ j] * pow_ii(&c_n1, &i__5);
}
/* L140: */
}
/* L150: */
}
sgbequ_(&m, &n, &kl, &ku, ab, &c__13, r__, c__, &rcond, &
ccond, &norm, &info);
if (info != 0) {
if (! (n + kl < m && info == n + kl + 1 || m + ku < n
&& info == (m << 1) + ku + 1)) {
reslts[1] = 1.f;
}
} else {
if (n != 0 && m != 0) {
rcmin = r__[0];
rcmax = r__[0];
i__3 = m;
for (i__ = 1; i__ <= i__3; ++i__) {
/* Computing MIN */
r__1 = rcmin, r__2 = r__[i__ - 1];
rcmin = dmin(r__1,r__2);
/* Computing MAX */
r__1 = rcmax, r__2 = r__[i__ - 1];
rcmax = dmax(r__1,r__2);
/* L160: */
}
ratio = rcmin / rcmax;
/* Computing MAX */
r__2 = reslts[1], r__3 = (r__1 = (rcond - ratio) /
ratio, dabs(r__1));
reslts[1] = dmax(r__2,r__3);
rcmin = c__[0];
rcmax = c__[0];
i__3 = n;
for (j = 1; j <= i__3; ++j) {
/* Computing MIN */
r__1 = rcmin, r__2 = c__[j - 1];
rcmin = dmin(r__1,r__2);
/* Computing MAX */
r__1 = rcmax, r__2 = c__[j - 1];
rcmax = dmax(r__1,r__2);
/* L170: */
}
ratio = rcmin / rcmax;
/* Computing MAX */
r__2 = reslts[1], r__3 = (r__1 = (ccond - ratio) /
ratio, dabs(r__1));
reslts[1] = dmax(r__2,r__3);
/* Computing MAX */
r__2 = reslts[1], r__3 = (r__1 = (norm - pow[n +
m]) / pow[n + m], dabs(r__1));
reslts[1] = dmax(r__2,r__3);
i__3 = m;
for (i__ = 1; i__ <= i__3; ++i__) {
rcmax = 0.f;
i__4 = n;
for (j = 1; j <= i__4; ++j) {
if (i__ <= j + kl && i__ >= j - ku) {
ratio = (r__1 = r__[i__ - 1] * pow[
i__ + j] * c__[j - 1], dabs(
r__1));
rcmax = dmax(rcmax,ratio);
}
/* L180: */
}
/* Computing MAX */
r__2 = reslts[1], r__3 = (r__1 = 1.f - rcmax,
dabs(r__1));
reslts[1] = dmax(r__2,r__3);
/* L190: */
}
i__3 = n;
for (j = 1; j <= i__3; ++j) {
rcmax = 0.f;
i__4 = m;
for (i__ = 1; i__ <= i__4; ++i__) {
if (i__ <= j + kl && i__ >= j - ku) {
ratio = (r__1 = r__[i__ - 1] * pow[
i__ + j] * c__[j - 1], dabs(
r__1));
rcmax = dmax(rcmax,ratio);
}
/* L200: */
}
/* Computing MAX */
r__2 = reslts[1], r__3 = (r__1 = 1.f - rcmax,
dabs(r__1));
reslts[1] = dmax(r__2,r__3);
/* L210: */
}
}
}
/* L220: */
}
/* L230: */
}
/* L240: */
}
/* L250: */
}
reslts[1] /= eps;
/* Test SPOEQU */
for (n = 0; n <= 5; ++n) {
for (i__ = 1; i__ <= 5; ++i__) {
for (j = 1; j <= 5; ++j) {
if (i__ <= n && j == i__) {
i__1 = i__ + j;
a[i__ + j * 5 - 6] = pow[i__ + j] * pow_ii(&c_n1, &i__1);
} else {
a[i__ + j * 5 - 6] = 0.f;
}
/* L260: */
}
/* L270: */
}
spoequ_(&n, a, &c__5, r__, &rcond, &norm, &info);
if (info != 0) {
reslts[2] = 1.f;
} else {
if (n != 0) {
/* Computing MAX */
r__2 = reslts[2], r__3 = (r__1 = (rcond - rpow[n - 1]) / rpow[
n - 1], dabs(r__1));
reslts[2] = dmax(r__2,r__3);
/* Computing MAX */
r__2 = reslts[2], r__3 = (r__1 = (norm - pow[n * 2]) / pow[n *
2], dabs(r__1));
reslts[2] = dmax(r__2,r__3);
i__1 = n;
for (i__ = 1; i__ <= i__1; ++i__) {
/* Computing MAX */
r__2 = reslts[2], r__3 = (r__1 = (r__[i__ - 1] - rpow[i__]
) / rpow[i__], dabs(r__1));
reslts[2] = dmax(r__2,r__3);
/* L280: */
}
}
}
/* L290: */
}
a[18] = -1.f;
spoequ_(&c__5, a, &c__5, r__, &rcond, &norm, &info);
if (info != 4) {
reslts[2] = 1.f;
}
reslts[2] /= eps;
/* Test SPPEQU */
for (n = 0; n <= 5; ++n) {
/* Upper triangular packed storage */
i__1 = n * (n + 1) / 2;
for (i__ = 1; i__ <= i__1; ++i__) {
ap[i__ - 1] = 0.f;
/* L300: */
}
i__1 = n;
for (i__ = 1; i__ <= i__1; ++i__) {
ap[i__ * (i__ + 1) / 2 - 1] = pow[i__ * 2];
/* L310: */
}
sppequ_("U", &n, ap, r__, &rcond, &norm, &info);
if (info != 0) {
reslts[3] = 1.f;
} else {
if (n != 0) {
/* Computing MAX */
r__2 = reslts[3], r__3 = (r__1 = (rcond - rpow[n - 1]) / rpow[
n - 1], dabs(r__1));
reslts[3] = dmax(r__2,r__3);
/* Computing MAX */
r__2 = reslts[3], r__3 = (r__1 = (norm - pow[n * 2]) / pow[n *
2], dabs(r__1));
reslts[3] = dmax(r__2,r__3);
i__1 = n;
for (i__ = 1; i__ <= i__1; ++i__) {
/* Computing MAX */
r__2 = reslts[3], r__3 = (r__1 = (r__[i__ - 1] - rpow[i__]
) / rpow[i__], dabs(r__1));
reslts[3] = dmax(r__2,r__3);
/* L320: */
}
}
}
/* Lower triangular packed storage */
i__1 = n * (n + 1) / 2;
for (i__ = 1; i__ <= i__1; ++i__) {
ap[i__ - 1] = 0.f;
/* L330: */
}
j = 1;
i__1 = n;
for (i__ = 1; i__ <= i__1; ++i__) {
ap[j - 1] = pow[i__ * 2];
j += n - i__ + 1;
/* L340: */
}
sppequ_("L", &n, ap, r__, &rcond, &norm, &info);
if (info != 0) {
reslts[3] = 1.f;
} else {
if (n != 0) {
/* Computing MAX */
r__2 = reslts[3], r__3 = (r__1 = (rcond - rpow[n - 1]) / rpow[
n - 1], dabs(r__1));
reslts[3] = dmax(r__2,r__3);
/* Computing MAX */
r__2 = reslts[3], r__3 = (r__1 = (norm - pow[n * 2]) / pow[n *
2], dabs(r__1));
reslts[3] = dmax(r__2,r__3);
i__1 = n;
for (i__ = 1; i__ <= i__1; ++i__) {
/* Computing MAX */
r__2 = reslts[3], r__3 = (r__1 = (r__[i__ - 1] - rpow[i__]
) / rpow[i__], dabs(r__1));
reslts[3] = dmax(r__2,r__3);
/* L350: */
}
}
}
/* L360: */
}
i__ = 13;
ap[i__ - 1] = -1.f;
sppequ_("L", &c__5, ap, r__, &rcond, &norm, &info);
if (info != 4) {
reslts[3] = 1.f;
}
reslts[3] /= eps;
/* Test SPBEQU */
for (n = 0; n <= 5; ++n) {
/* Computing MAX */
i__2 = n - 1;
i__1 = max(i__2,0);
for (kl = 0; kl <= i__1; ++kl) {
/* Test upper triangular storage */
for (j = 1; j <= 5; ++j) {
for (i__ = 1; i__ <= 13; ++i__) {
ab[i__ + j * 13 - 14] = 0.f;
/* L370: */
}
/* L380: */
}
i__2 = n;
for (j = 1; j <= i__2; ++j) {
ab[kl + 1 + j * 13 - 14] = pow[j * 2];
/* L390: */
}
spbequ_("U", &n, &kl, ab, &c__13, r__, &rcond, &norm, &info);
if (info != 0) {
reslts[4] = 1.f;
} else {
if (n != 0) {
/* Computing MAX */
r__2 = reslts[4], r__3 = (r__1 = (rcond - rpow[n - 1]) /
rpow[n - 1], dabs(r__1));
reslts[4] = dmax(r__2,r__3);
/* Computing MAX */
r__2 = reslts[4], r__3 = (r__1 = (norm - pow[n * 2]) /
pow[n * 2], dabs(r__1));
reslts[4] = dmax(r__2,r__3);
i__2 = n;
for (i__ = 1; i__ <= i__2; ++i__) {
/* Computing MAX */
r__2 = reslts[4], r__3 = (r__1 = (r__[i__ - 1] - rpow[
i__]) / rpow[i__], dabs(r__1));
reslts[4] = dmax(r__2,r__3);
/* L400: */
}
}
}
if (n != 0) {
/* Computing MAX */
i__2 = n - 1;
ab[kl + 1 + max(i__2,1) * 13 - 14] = -1.f;
spbequ_("U", &n, &kl, ab, &c__13, r__, &rcond, &norm, &info);
/* Computing MAX */
i__2 = n - 1;
if (info != max(i__2,1)) {
reslts[4] = 1.f;
}
}
/* Test lower triangular storage */
for (j = 1; j <= 5; ++j) {
for (i__ = 1; i__ <= 13; ++i__) {
ab[i__ + j * 13 - 14] = 0.f;
/* L410: */
}
/* L420: */
}
i__2 = n;
for (j = 1; j <= i__2; ++j) {
ab[j * 13 - 13] = pow[j * 2];
/* L430: */
}
spbequ_("L", &n, &kl, ab, &c__13, r__, &rcond, &norm, &info);
if (info != 0) {
reslts[4] = 1.f;
} else {
if (n != 0) {
/* Computing MAX */
r__2 = reslts[4], r__3 = (r__1 = (rcond - rpow[n - 1]) /
rpow[n - 1], dabs(r__1));
reslts[4] = dmax(r__2,r__3);
/* Computing MAX */
r__2 = reslts[4], r__3 = (r__1 = (norm - pow[n * 2]) /
pow[n * 2], dabs(r__1));
reslts[4] = dmax(r__2,r__3);
i__2 = n;
for (i__ = 1; i__ <= i__2; ++i__) {
/* Computing MAX */
r__2 = reslts[4], r__3 = (r__1 = (r__[i__ - 1] - rpow[
i__]) / rpow[i__], dabs(r__1));
reslts[4] = dmax(r__2,r__3);
/* L440: */
}
}
}
if (n != 0) {
/* Computing MAX */
i__2 = n - 1;
ab[max(i__2,1) * 13 - 13] = -1.f;
spbequ_("L", &n, &kl, ab, &c__13, r__, &rcond, &norm, &info);
/* Computing MAX */
i__2 = n - 1;
if (info != max(i__2,1)) {
reslts[4] = 1.f;
}
}
/* L450: */
}
/* L460: */
}
reslts[4] /= eps;
ok = reslts[0] <= *thresh && reslts[1] <= *thresh && reslts[2] <= *thresh
&& reslts[3] <= *thresh && reslts[4] <= *thresh;
io___25.ciunit = *nout;
s_wsle(&io___25);
e_wsle();
if (ok) {
io___26.ciunit = *nout;
s_wsfe(&io___26);
do_fio(&c__1, path, (ftnlen)3);
e_wsfe();
} else {
if (reslts[0] > *thresh) {
io___27.ciunit = *nout;
s_wsfe(&io___27);
do_fio(&c__1, (char *)&reslts[0], (ftnlen)sizeof(real));
do_fio(&c__1, (char *)&(*thresh), (ftnlen)sizeof(real));
e_wsfe();
}
if (reslts[1] > *thresh) {
io___28.ciunit = *nout;
s_wsfe(&io___28);
do_fio(&c__1, (char *)&reslts[1], (ftnlen)sizeof(real));
do_fio(&c__1, (char *)&(*thresh), (ftnlen)sizeof(real));
e_wsfe();
}
if (reslts[2] > *thresh) {
io___29.ciunit = *nout;
s_wsfe(&io___29);
do_fio(&c__1, (char *)&reslts[2], (ftnlen)sizeof(real));
do_fio(&c__1, (char *)&(*thresh), (ftnlen)sizeof(real));
e_wsfe();
}
if (reslts[3] > *thresh) {
io___30.ciunit = *nout;
s_wsfe(&io___30);
do_fio(&c__1, (char *)&reslts[3], (ftnlen)sizeof(real));
do_fio(&c__1, (char *)&(*thresh), (ftnlen)sizeof(real));
e_wsfe();
}
if (reslts[4] > *thresh) {
io___31.ciunit = *nout;
s_wsfe(&io___31);
do_fio(&c__1, (char *)&reslts[4], (ftnlen)sizeof(real));
do_fio(&c__1, (char *)&(*thresh), (ftnlen)sizeof(real));
e_wsfe();
}
}
return 0;
/* End of SCHKEQ */
} /* schkeq_ */
int dlalsa_(int *icompq, int *smlsiz, int *n,
int *nrhs, double *b, int *ldb, double *bx, int *
ldbx, double *u, int *ldu, double *vt, int *k,
double *difl, double *difr, double *z__, double *
poles, int *givptr, int *givcol, int *ldgcol, int *
perm, double *givnum, double *c__, double *s, double *
work, int *iwork, int *info)
{
/* System generated locals */
int givcol_dim1, givcol_offset, perm_dim1, perm_offset, b_dim1,
b_offset, bx_dim1, bx_offset, difl_dim1, difl_offset, difr_dim1,
difr_offset, givnum_dim1, givnum_offset, poles_dim1, poles_offset,
u_dim1, u_offset, vt_dim1, vt_offset, z_dim1, z_offset, i__1,
i__2;
/* Builtin functions */
int pow_ii(int *, int *);
/* Local variables */
int i__, j, i1, ic, lf, nd, ll, nl, nr, im1, nlf, nrf, lvl, ndb1,
nlp1, lvl2, nrp1, nlvl, sqre;
extern int dgemm_(char *, char *, int *, int *,
int *, double *, double *, int *, double *,
int *, double *, double *, int *);
int inode, ndiml, ndimr;
extern int dcopy_(int *, double *, int *,
double *, int *), dlals0_(int *, int *, int *,
int *, int *, double *, int *, double *,
int *, int *, int *, int *, int *, double
*, int *, double *, double *, double *,
double *, int *, double *, double *, double *,
int *), dlasdt_(int *, int *, int *, int *,
int *, int *, int *), xerbla_(char *, int *);
/* -- LAPACK routine (version 3.2) -- */
/* Univ. of Tennessee, Univ. of California Berkeley and NAG Ltd.. */
/* November 2006 */
/* .. Scalar Arguments .. */
/* .. */
/* .. Array Arguments .. */
/* .. */
/* Purpose */
/* ======= */
/* DLALSA is an itermediate step in solving the least squares problem */
/* by computing the SVD of the coefficient matrix in compact form (The */
/* singular vectors are computed as products of simple orthorgonal */
/* matrices.). */
/* If ICOMPQ = 0, DLALSA applies the inverse of the left singular vector */
/* matrix of an upper bidiagonal matrix to the right hand side; and if */
/* ICOMPQ = 1, DLALSA applies the right singular vector matrix to the */
/* right hand side. The singular vector matrices were generated in */
/* compact form by DLALSA. */
/* Arguments */
/* ========= */
/* ICOMPQ (input) INTEGER */
/* Specifies whether the left or the right singular vector */
/* matrix is involved. */
/* = 0: Left singular vector matrix */
/* = 1: Right singular vector matrix */
/* SMLSIZ (input) INTEGER */
/* The maximum size of the subproblems at the bottom of the */
/* computation tree. */
/* N (input) INTEGER */
/* The row and column dimensions of the upper bidiagonal matrix. */
/* NRHS (input) INTEGER */
/* The number of columns of B and BX. NRHS must be at least 1. */
/* B (input/output) DOUBLE PRECISION array, dimension ( LDB, NRHS ) */
/* On input, B contains the right hand sides of the least */
/* squares problem in rows 1 through M. */
/* On output, B contains the solution X in rows 1 through N. */
/* LDB (input) INTEGER */
/* The leading dimension of B in the calling subprogram. */
/* LDB must be at least MAX(1,MAX( M, N ) ). */
/* BX (output) DOUBLE PRECISION array, dimension ( LDBX, NRHS ) */
/* On exit, the result of applying the left or right singular */
/* vector matrix to B. */
/* LDBX (input) INTEGER */
/* The leading dimension of BX. */
/* U (input) DOUBLE PRECISION array, dimension ( LDU, SMLSIZ ). */
/* On entry, U contains the left singular vector matrices of all */
/* subproblems at the bottom level. */
/* LDU (input) INTEGER, LDU = > N. */
/* The leading dimension of arrays U, VT, DIFL, DIFR, */
/* POLES, GIVNUM, and Z. */
/* VT (input) DOUBLE PRECISION array, dimension ( LDU, SMLSIZ+1 ). */
/* On entry, VT' contains the right singular vector matrices of */
/* all subproblems at the bottom level. */
/* K (input) INTEGER array, dimension ( N ). */
/* DIFL (input) DOUBLE PRECISION array, dimension ( LDU, NLVL ). */
/* where NLVL = INT(log_2 (N/(SMLSIZ+1))) + 1. */
/* DIFR (input) DOUBLE PRECISION array, dimension ( LDU, 2 * NLVL ). */
/* On entry, DIFL(*, I) and DIFR(*, 2 * I -1) record */
/* distances between singular values on the I-th level and */
/* singular values on the (I -1)-th level, and DIFR(*, 2 * I) */
/* record the normalizing factors of the right singular vectors */
/* matrices of subproblems on I-th level. */
/* Z (input) DOUBLE PRECISION array, dimension ( LDU, NLVL ). */
/* On entry, Z(1, I) contains the components of the deflation- */
/* adjusted updating row vector for subproblems on the I-th */
/* level. */
/* POLES (input) DOUBLE PRECISION array, dimension ( LDU, 2 * NLVL ). */
/* On entry, POLES(*, 2 * I -1: 2 * I) contains the new and old */
/* singular values involved in the secular equations on the I-th */
/* level. */
/* GIVPTR (input) INTEGER array, dimension ( N ). */
/* On entry, GIVPTR( I ) records the number of Givens */
/* rotations performed on the I-th problem on the computation */
/* tree. */
/* GIVCOL (input) INTEGER array, dimension ( LDGCOL, 2 * NLVL ). */
/* On entry, for each I, GIVCOL(*, 2 * I - 1: 2 * I) records the */
/* locations of Givens rotations performed on the I-th level on */
/* the computation tree. */
/* LDGCOL (input) INTEGER, LDGCOL = > N. */
/* The leading dimension of arrays GIVCOL and PERM. */
/* PERM (input) INTEGER array, dimension ( LDGCOL, NLVL ). */
/* On entry, PERM(*, I) records permutations done on the I-th */
/* level of the computation tree. */
/* GIVNUM (input) DOUBLE PRECISION array, dimension ( LDU, 2 * NLVL ). */
/* On entry, GIVNUM(*, 2 *I -1 : 2 * I) records the C- and S- */
/* values of Givens rotations performed on the I-th level on the */
/* computation tree. */
/* C (input) DOUBLE PRECISION array, dimension ( N ). */
/* On entry, if the I-th subproblem is not square, */
/* C( I ) contains the C-value of a Givens rotation related to */
/* the right null space of the I-th subproblem. */
/* S (input) DOUBLE PRECISION array, dimension ( N ). */
/* On entry, if the I-th subproblem is not square, */
/* S( I ) contains the S-value of a Givens rotation related to */
/* the right null space of the I-th subproblem. */
/* WORK (workspace) DOUBLE PRECISION array. */
/* The dimension must be at least N. */
/* IWORK (workspace) INTEGER array. */
/* The dimension must be at least 3 * N */
/* INFO (output) INTEGER */
/* = 0: successful exit. */
/* < 0: if INFO = -i, the i-th argument had an illegal value. */
/* Further Details */
/* =============== */
/* Based on contributions by */
/* Ming Gu and Ren-Cang Li, Computer Science Division, University of */
/* California at Berkeley, USA */
/* Osni Marques, LBNL/NERSC, USA */
/* ===================================================================== */
/* .. Parameters .. */
/* .. */
/* .. Local Scalars .. */
/* .. */
/* .. External Subroutines .. */
/* .. */
/* .. Executable Statements .. */
/* Test the input parameters. */
/* Parameter adjustments */
b_dim1 = *ldb;
b_offset = 1 + b_dim1;
b -= b_offset;
bx_dim1 = *ldbx;
bx_offset = 1 + bx_dim1;
bx -= bx_offset;
givnum_dim1 = *ldu;
givnum_offset = 1 + givnum_dim1;
givnum -= givnum_offset;
poles_dim1 = *ldu;
poles_offset = 1 + poles_dim1;
poles -= poles_offset;
z_dim1 = *ldu;
z_offset = 1 + z_dim1;
z__ -= z_offset;
difr_dim1 = *ldu;
difr_offset = 1 + difr_dim1;
difr -= difr_offset;
difl_dim1 = *ldu;
difl_offset = 1 + difl_dim1;
difl -= difl_offset;
vt_dim1 = *ldu;
vt_offset = 1 + vt_dim1;
vt -= vt_offset;
u_dim1 = *ldu;
u_offset = 1 + u_dim1;
u -= u_offset;
--k;
--givptr;
perm_dim1 = *ldgcol;
perm_offset = 1 + perm_dim1;
perm -= perm_offset;
givcol_dim1 = *ldgcol;
givcol_offset = 1 + givcol_dim1;
givcol -= givcol_offset;
--c__;
--s;
--work;
--iwork;
/* Function Body */
*info = 0;
if (*icompq < 0 || *icompq > 1) {
*info = -1;
} else if (*smlsiz < 3) {
*info = -2;
} else if (*n < *smlsiz) {
*info = -3;
} else if (*nrhs < 1) {
*info = -4;
} else if (*ldb < *n) {
*info = -6;
} else if (*ldbx < *n) {
*info = -8;
} else if (*ldu < *n) {
*info = -10;
} else if (*ldgcol < *n) {
*info = -19;
}
if (*info != 0) {
i__1 = -(*info);
xerbla_("DLALSA", &i__1);
return 0;
}
/* Book-keeping and setting up the computation tree. */
inode = 1;
ndiml = inode + *n;
ndimr = ndiml + *n;
dlasdt_(n, &nlvl, &nd, &iwork[inode], &iwork[ndiml], &iwork[ndimr],
smlsiz);
/* The following code applies back the left singular vector factors. */
/* For applying back the right singular vector factors, go to 50. */
if (*icompq == 1) {
goto L50;
}
/* The nodes on the bottom level of the tree were solved */
/* by DLASDQ. The corresponding left and right singular vector */
/* matrices are in explicit form. First apply back the left */
/* singular vector matrices. */
ndb1 = (nd + 1) / 2;
i__1 = nd;
for (i__ = ndb1; i__ <= i__1; ++i__) {
/* IC : center row of each node */
/* NL : number of rows of left subproblem */
/* NR : number of rows of right subproblem */
/* NLF: starting row of the left subproblem */
/* NRF: starting row of the right subproblem */
i1 = i__ - 1;
ic = iwork[inode + i1];
nl = iwork[ndiml + i1];
nr = iwork[ndimr + i1];
nlf = ic - nl;
nrf = ic + 1;
dgemm_("T", "N", &nl, nrhs, &nl, &c_b7, &u[nlf + u_dim1], ldu, &b[nlf
+ b_dim1], ldb, &c_b8, &bx[nlf + bx_dim1], ldbx);
dgemm_("T", "N", &nr, nrhs, &nr, &c_b7, &u[nrf + u_dim1], ldu, &b[nrf
+ b_dim1], ldb, &c_b8, &bx[nrf + bx_dim1], ldbx);
/* L10: */
}
/* Next copy the rows of B that correspond to unchanged rows */
/* in the bidiagonal matrix to BX. */
i__1 = nd;
for (i__ = 1; i__ <= i__1; ++i__) {
ic = iwork[inode + i__ - 1];
dcopy_(nrhs, &b[ic + b_dim1], ldb, &bx[ic + bx_dim1], ldbx);
/* L20: */
}
/* Finally go through the left singular vector matrices of all */
/* the other subproblems bottom-up on the tree. */
j = pow_ii(&c__2, &nlvl);
sqre = 0;
for (lvl = nlvl; lvl >= 1; --lvl) {
lvl2 = (lvl << 1) - 1;
/* find the first node LF and last node LL on */
/* the current level LVL */
if (lvl == 1) {
lf = 1;
ll = 1;
} else {
i__1 = lvl - 1;
lf = pow_ii(&c__2, &i__1);
ll = (lf << 1) - 1;
}
i__1 = ll;
for (i__ = lf; i__ <= i__1; ++i__) {
im1 = i__ - 1;
ic = iwork[inode + im1];
nl = iwork[ndiml + im1];
nr = iwork[ndimr + im1];
nlf = ic - nl;
nrf = ic + 1;
--j;
dlals0_(icompq, &nl, &nr, &sqre, nrhs, &bx[nlf + bx_dim1], ldbx, &
b[nlf + b_dim1], ldb, &perm[nlf + lvl * perm_dim1], &
givptr[j], &givcol[nlf + lvl2 * givcol_dim1], ldgcol, &
givnum[nlf + lvl2 * givnum_dim1], ldu, &poles[nlf + lvl2 *
poles_dim1], &difl[nlf + lvl * difl_dim1], &difr[nlf +
lvl2 * difr_dim1], &z__[nlf + lvl * z_dim1], &k[j], &c__[
j], &s[j], &work[1], info);
/* L30: */
}
/* L40: */
}
goto L90;
/* ICOMPQ = 1: applying back the right singular vector factors. */
L50:
/* First now go through the right singular vector matrices of all */
/* the tree nodes top-down. */
j = 0;
i__1 = nlvl;
for (lvl = 1; lvl <= i__1; ++lvl) {
lvl2 = (lvl << 1) - 1;
/* Find the first node LF and last node LL on */
/* the current level LVL. */
if (lvl == 1) {
lf = 1;
ll = 1;
} else {
i__2 = lvl - 1;
lf = pow_ii(&c__2, &i__2);
ll = (lf << 1) - 1;
}
i__2 = lf;
for (i__ = ll; i__ >= i__2; --i__) {
im1 = i__ - 1;
ic = iwork[inode + im1];
nl = iwork[ndiml + im1];
nr = iwork[ndimr + im1];
nlf = ic - nl;
nrf = ic + 1;
if (i__ == ll) {
sqre = 0;
} else {
sqre = 1;
}
++j;
dlals0_(icompq, &nl, &nr, &sqre, nrhs, &b[nlf + b_dim1], ldb, &bx[
nlf + bx_dim1], ldbx, &perm[nlf + lvl * perm_dim1], &
givptr[j], &givcol[nlf + lvl2 * givcol_dim1], ldgcol, &
givnum[nlf + lvl2 * givnum_dim1], ldu, &poles[nlf + lvl2 *
poles_dim1], &difl[nlf + lvl * difl_dim1], &difr[nlf +
lvl2 * difr_dim1], &z__[nlf + lvl * z_dim1], &k[j], &c__[
j], &s[j], &work[1], info);
/* L60: */
}
/* L70: */
}
/* The nodes on the bottom level of the tree were solved */
/* by DLASDQ. The corresponding right singular vector */
/* matrices are in explicit form. Apply them back. */
ndb1 = (nd + 1) / 2;
i__1 = nd;
for (i__ = ndb1; i__ <= i__1; ++i__) {
i1 = i__ - 1;
ic = iwork[inode + i1];
nl = iwork[ndiml + i1];
nr = iwork[ndimr + i1];
nlp1 = nl + 1;
if (i__ == nd) {
nrp1 = nr;
} else {
nrp1 = nr + 1;
}
nlf = ic - nl;
nrf = ic + 1;
dgemm_("T", "N", &nlp1, nrhs, &nlp1, &c_b7, &vt[nlf + vt_dim1], ldu, &
b[nlf + b_dim1], ldb, &c_b8, &bx[nlf + bx_dim1], ldbx);
dgemm_("T", "N", &nrp1, nrhs, &nrp1, &c_b7, &vt[nrf + vt_dim1], ldu, &
b[nrf + b_dim1], ldb, &c_b8, &bx[nrf + bx_dim1], ldbx);
/* L80: */
}
L90:
return 0;
/* End of DLALSA */
} /* dlalsa_ */
/* Subroutine */ int slaeda_(integer *n, integer *tlvls, integer *curlvl,
integer *curpbm, integer *prmptr, integer *perm, integer *givptr,
integer *givcol, real *givnum, real *q, integer *qptr, real *z__,
real *ztemp, integer *info)
{
/* System generated locals */
integer i__1, i__2, i__3;
/* Builtin functions */
integer pow_ii(integer *, integer *);
double sqrt(doublereal);
/* Local variables */
integer i__, k, mid, ptr, curr;
extern /* Subroutine */ int srot_(integer *, real *, integer *, real *,
integer *, real *, real *);
integer bsiz1, bsiz2, psiz1, psiz2, zptr1;
extern /* Subroutine */ int sgemv_(char *, integer *, integer *, real *,
real *, integer *, real *, integer *, real *, real *, integer *), scopy_(integer *, real *, integer *, real *, integer *),
xerbla_(char *, integer *);
/* -- LAPACK routine (version 3.2) -- */
/* Univ. of Tennessee, Univ. of California Berkeley and NAG Ltd.. */
/* November 2006 */
/* .. Scalar Arguments .. */
/* .. */
/* .. Array Arguments .. */
/* .. */
/* Purpose */
/* ======= */
/* SLAEDA computes the Z vector corresponding to the merge step in the */
/* CURLVLth step of the merge process with TLVLS steps for the CURPBMth */
/* problem. */
/* Arguments */
/* ========= */
/* N (input) INTEGER */
/* The dimension of the symmetric tridiagonal matrix. N >= 0. */
/* TLVLS (input) INTEGER */
/* The total number of merging levels in the overall divide and */
/* conquer tree. */
/* CURLVL (input) INTEGER */
/* The current level in the overall merge routine, */
/* 0 <= curlvl <= tlvls. */
/* CURPBM (input) INTEGER */
/* The current problem in the current level in the overall */
/* merge routine (counting from upper left to lower right). */
/* PRMPTR (input) INTEGER array, dimension (N lg N) */
/* Contains a list of pointers which indicate where in PERM a */
/* level's permutation is stored. PRMPTR(i+1) - PRMPTR(i) */
/* indicates the size of the permutation and incidentally the */
/* size of the full, non-deflated problem. */
/* PERM (input) INTEGER array, dimension (N lg N) */
/* Contains the permutations (from deflation and sorting) to be */
/* applied to each eigenblock. */
/* GIVPTR (input) INTEGER array, dimension (N lg N) */
/* Contains a list of pointers which indicate where in GIVCOL a */
/* level's Givens rotations are stored. GIVPTR(i+1) - GIVPTR(i) */
/* indicates the number of Givens rotations. */
/* GIVCOL (input) INTEGER array, dimension (2, N lg N) */
/* Each pair of numbers indicates a pair of columns to take place */
/* in a Givens rotation. */
/* GIVNUM (input) REAL array, dimension (2, N lg N) */
/* Each number indicates the S value to be used in the */
/* corresponding Givens rotation. */
/* Q (input) REAL array, dimension (N**2) */
/* Contains the square eigenblocks from previous levels, the */
/* starting positions for blocks are given by QPTR. */
/* QPTR (input) INTEGER array, dimension (N+2) */
/* Contains a list of pointers which indicate where in Q an */
/* eigenblock is stored. SQRT( QPTR(i+1) - QPTR(i) ) indicates */
/* the size of the block. */
/* Z (output) REAL array, dimension (N) */
/* On output this vector contains the updating vector (the last */
/* row of the first sub-eigenvector matrix and the first row of */
/* the second sub-eigenvector matrix). */
/* ZTEMP (workspace) REAL array, dimension (N) */
/* INFO (output) INTEGER */
/* = 0: successful exit. */
/* < 0: if INFO = -i, the i-th argument had an illegal value. */
/* Further Details */
/* =============== */
/* Based on contributions by */
/* Jeff Rutter, Computer Science Division, University of California */
/* at Berkeley, USA */
/* ===================================================================== */
/* .. Parameters .. */
/* .. */
/* .. Local Scalars .. */
/* .. */
/* .. External Subroutines .. */
/* .. */
/* .. Intrinsic Functions .. */
/* .. */
/* .. Executable Statements .. */
/* Test the input parameters. */
/* Parameter adjustments */
--ztemp;
--z__;
--qptr;
--q;
givnum -= 3;
givcol -= 3;
--givptr;
--perm;
--prmptr;
/* Function Body */
*info = 0;
if (*n < 0) {
*info = -1;
}
if (*info != 0) {
i__1 = -(*info);
xerbla_("SLAEDA", &i__1);
return 0;
}
/* Quick return if possible */
if (*n == 0) {
return 0;
}
/* Determine location of first number in second half. */
mid = *n / 2 + 1;
/* Gather last/first rows of appropriate eigenblocks into center of Z */
ptr = 1;
/* Determine location of lowest level subproblem in the full storage */
/* scheme */
i__1 = *curlvl - 1;
curr = ptr + *curpbm * pow_ii(&c__2, curlvl) + pow_ii(&c__2, &i__1) - 1;
/* Determine size of these matrices. We add HALF to the value of */
/* the SQRT in case the machine underestimates one of these square */
/* roots. */
bsiz1 = (integer) (sqrt((real) (qptr[curr + 1] - qptr[curr])) + .5f);
bsiz2 = (integer) (sqrt((real) (qptr[curr + 2] - qptr[curr + 1])) + .5f);
i__1 = mid - bsiz1 - 1;
for (k = 1; k <= i__1; ++k) {
z__[k] = 0.f;
/* L10: */
}
scopy_(&bsiz1, &q[qptr[curr] + bsiz1 - 1], &bsiz1, &z__[mid - bsiz1], &
c__1);
scopy_(&bsiz2, &q[qptr[curr + 1]], &bsiz2, &z__[mid], &c__1);
i__1 = *n;
for (k = mid + bsiz2; k <= i__1; ++k) {
z__[k] = 0.f;
/* L20: */
}
/* Loop thru remaining levels 1 -> CURLVL applying the Givens */
/* rotations and permutation and then multiplying the center matrices */
/* against the current Z. */
ptr = pow_ii(&c__2, tlvls) + 1;
i__1 = *curlvl - 1;
for (k = 1; k <= i__1; ++k) {
i__2 = *curlvl - k;
i__3 = *curlvl - k - 1;
curr = ptr + *curpbm * pow_ii(&c__2, &i__2) + pow_ii(&c__2, &i__3) -
1;
psiz1 = prmptr[curr + 1] - prmptr[curr];
psiz2 = prmptr[curr + 2] - prmptr[curr + 1];
zptr1 = mid - psiz1;
/* Apply Givens at CURR and CURR+1 */
i__2 = givptr[curr + 1] - 1;
for (i__ = givptr[curr]; i__ <= i__2; ++i__) {
srot_(&c__1, &z__[zptr1 + givcol[(i__ << 1) + 1] - 1], &c__1, &
z__[zptr1 + givcol[(i__ << 1) + 2] - 1], &c__1, &givnum[(
i__ << 1) + 1], &givnum[(i__ << 1) + 2]);
/* L30: */
}
i__2 = givptr[curr + 2] - 1;
for (i__ = givptr[curr + 1]; i__ <= i__2; ++i__) {
srot_(&c__1, &z__[mid - 1 + givcol[(i__ << 1) + 1]], &c__1, &z__[
mid - 1 + givcol[(i__ << 1) + 2]], &c__1, &givnum[(i__ <<
1) + 1], &givnum[(i__ << 1) + 2]);
/* L40: */
}
psiz1 = prmptr[curr + 1] - prmptr[curr];
psiz2 = prmptr[curr + 2] - prmptr[curr + 1];
i__2 = psiz1 - 1;
for (i__ = 0; i__ <= i__2; ++i__) {
ztemp[i__ + 1] = z__[zptr1 + perm[prmptr[curr] + i__] - 1];
/* L50: */
}
i__2 = psiz2 - 1;
for (i__ = 0; i__ <= i__2; ++i__) {
ztemp[psiz1 + i__ + 1] = z__[mid + perm[prmptr[curr + 1] + i__] -
1];
/* L60: */
}
/* Multiply Blocks at CURR and CURR+1 */
/* Determine size of these matrices. We add HALF to the value of */
/* the SQRT in case the machine underestimates one of these */
/* square roots. */
bsiz1 = (integer) (sqrt((real) (qptr[curr + 1] - qptr[curr])) + .5f);
bsiz2 = (integer) (sqrt((real) (qptr[curr + 2] - qptr[curr + 1])) +
.5f);
if (bsiz1 > 0) {
sgemv_("T", &bsiz1, &bsiz1, &c_b24, &q[qptr[curr]], &bsiz1, &
ztemp[1], &c__1, &c_b26, &z__[zptr1], &c__1);
}
i__2 = psiz1 - bsiz1;
scopy_(&i__2, &ztemp[bsiz1 + 1], &c__1, &z__[zptr1 + bsiz1], &c__1);
if (bsiz2 > 0) {
sgemv_("T", &bsiz2, &bsiz2, &c_b24, &q[qptr[curr + 1]], &bsiz2, &
ztemp[psiz1 + 1], &c__1, &c_b26, &z__[mid], &c__1);
}
i__2 = psiz2 - bsiz2;
scopy_(&i__2, &ztemp[psiz1 + bsiz2 + 1], &c__1, &z__[mid + bsiz2], &
c__1);
i__2 = *tlvls - k;
ptr += pow_ii(&c__2, &i__2);
/* L70: */
}
return 0;
/* End of SLAEDA */
} /* slaeda_ */
/* Subroutine */
int slasd0_(integer *n, integer *sqre, real *d__, real *e, real *u, integer *ldu, real *vt, integer *ldvt, integer *smlsiz, integer *iwork, real *work, integer *info)
{
/* System generated locals */
integer u_dim1, u_offset, vt_dim1, vt_offset, i__1, i__2;
/* Builtin functions */
integer pow_ii(integer *, integer *);
/* Local variables */
integer i__, j, m, i1, ic, lf, nd, ll, nl, nr, im1, ncc, nlf, nrf, iwk, lvl, ndb1, nlp1, nrp1;
real beta;
integer idxq, nlvl;
real alpha;
integer inode, ndiml, idxqc, ndimr, itemp, sqrei;
extern /* Subroutine */
int slasd1_(integer *, integer *, integer *, real *, real *, real *, real *, integer *, real *, integer *, integer * , integer *, real *, integer *), xerbla_(char *, integer *), slasdq_(char *, integer *, integer *, integer *, integer *, integer *, real *, real *, real *, integer *, real *, integer * , real *, integer *, real *, integer *), slasdt_(integer * , integer *, integer *, integer *, integer *, integer *, integer * );
/* -- LAPACK auxiliary routine (version 3.4.2) -- */
/* -- LAPACK is a software package provided by Univ. of Tennessee, -- */
/* -- Univ. of California Berkeley, Univ. of Colorado Denver and NAG Ltd..-- */
/* September 2012 */
/* .. Scalar Arguments .. */
/* .. */
/* .. Array Arguments .. */
/* .. */
/* ===================================================================== */
/* .. Local Scalars .. */
/* .. */
/* .. External Subroutines .. */
/* .. */
/* .. Executable Statements .. */
/* Test the input parameters. */
/* Parameter adjustments */
--d__;
--e;
u_dim1 = *ldu;
u_offset = 1 + u_dim1;
u -= u_offset;
vt_dim1 = *ldvt;
vt_offset = 1 + vt_dim1;
vt -= vt_offset;
--iwork;
--work;
/* Function Body */
*info = 0;
if (*n < 0)
{
*info = -1;
}
else if (*sqre < 0 || *sqre > 1)
{
*info = -2;
}
m = *n + *sqre;
if (*ldu < *n)
{
*info = -6;
}
else if (*ldvt < m)
{
*info = -8;
}
else if (*smlsiz < 3)
{
*info = -9;
}
if (*info != 0)
{
i__1 = -(*info);
xerbla_("SLASD0", &i__1);
return 0;
}
/* If the input matrix is too small, call SLASDQ to find the SVD. */
if (*n <= *smlsiz)
{
slasdq_("U", sqre, n, &m, n, &c__0, &d__[1], &e[1], &vt[vt_offset], ldvt, &u[u_offset], ldu, &u[u_offset], ldu, &work[1], info);
return 0;
}
/* Set up the computation tree. */
inode = 1;
ndiml = inode + *n;
ndimr = ndiml + *n;
idxq = ndimr + *n;
iwk = idxq + *n;
slasdt_(n, &nlvl, &nd, &iwork[inode], &iwork[ndiml], &iwork[ndimr], smlsiz);
/* For the nodes on bottom level of the tree, solve */
/* their subproblems by SLASDQ. */
ndb1 = (nd + 1) / 2;
ncc = 0;
i__1 = nd;
for (i__ = ndb1;
i__ <= i__1;
++i__)
{
/* IC : center row of each node */
/* NL : number of rows of left subproblem */
/* NR : number of rows of right subproblem */
/* NLF: starting row of the left subproblem */
/* NRF: starting row of the right subproblem */
i1 = i__ - 1;
ic = iwork[inode + i1];
nl = iwork[ndiml + i1];
nlp1 = nl + 1;
nr = iwork[ndimr + i1];
nrp1 = nr + 1;
nlf = ic - nl;
nrf = ic + 1;
sqrei = 1;
slasdq_("U", &sqrei, &nl, &nlp1, &nl, &ncc, &d__[nlf], &e[nlf], &vt[ nlf + nlf * vt_dim1], ldvt, &u[nlf + nlf * u_dim1], ldu, &u[ nlf + nlf * u_dim1], ldu, &work[1], info);
if (*info != 0)
{
return 0;
}
itemp = idxq + nlf - 2;
i__2 = nl;
for (j = 1;
j <= i__2;
++j)
{
iwork[itemp + j] = j;
/* L10: */
}
if (i__ == nd)
{
sqrei = *sqre;
}
else
{
sqrei = 1;
}
nrp1 = nr + sqrei;
slasdq_("U", &sqrei, &nr, &nrp1, &nr, &ncc, &d__[nrf], &e[nrf], &vt[ nrf + nrf * vt_dim1], ldvt, &u[nrf + nrf * u_dim1], ldu, &u[ nrf + nrf * u_dim1], ldu, &work[1], info);
if (*info != 0)
{
return 0;
}
itemp = idxq + ic;
i__2 = nr;
for (j = 1;
j <= i__2;
++j)
{
iwork[itemp + j - 1] = j;
/* L20: */
}
/* L30: */
}
/* Now conquer each subproblem bottom-up. */
for (lvl = nlvl;
lvl >= 1;
--lvl)
{
/* Find the first node LF and last node LL on the */
/* current level LVL. */
if (lvl == 1)
{
lf = 1;
ll = 1;
}
else
{
i__1 = lvl - 1;
lf = pow_ii(&c__2, &i__1);
ll = (lf << 1) - 1;
}
i__1 = ll;
for (i__ = lf;
i__ <= i__1;
++i__)
{
im1 = i__ - 1;
ic = iwork[inode + im1];
nl = iwork[ndiml + im1];
nr = iwork[ndimr + im1];
nlf = ic - nl;
if (*sqre == 0 && i__ == ll)
{
sqrei = *sqre;
}
else
{
sqrei = 1;
}
idxqc = idxq + nlf - 1;
alpha = d__[ic];
beta = e[ic];
slasd1_(&nl, &nr, &sqrei, &d__[nlf], &alpha, &beta, &u[nlf + nlf * u_dim1], ldu, &vt[nlf + nlf * vt_dim1], ldvt, &iwork[ idxqc], &iwork[iwk], &work[1], info);
if (*info != 0)
{
return 0;
}
/* L40: */
}
/* L50: */
}
return 0;
/* End of SLASD0 */
}
/* Subroutine */ int dlaeda_(integer *n, integer *tlvls, integer *curlvl,
integer *curpbm, integer *prmptr, integer *perm, integer *givptr,
integer *givcol, doublereal *givnum, doublereal *q, integer *qptr,
doublereal *z, doublereal *ztemp, 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
=======
DLAEDA computes the Z vector corresponding to the merge step in the
CURLVLth step of the merge process with TLVLS steps for the CURPBMth
problem.
Arguments
=========
N (input) INTEGER
The dimension of the symmetric tridiagonal matrix. N >= 0.
TLVLS (input) INTEGER
The total number of merging levels in the overall divide and
conquer tree.
CURLVL (input) INTEGER
The current level in the overall merge routine,
0 <= curlvl <= tlvls.
CURPBM (input) INTEGER
The current problem in the current level in the overall
merge routine (counting from upper left to lower right).
PRMPTR (input) INTEGER array, dimension (N lg N)
Contains a list of pointers which indicate where in PERM a
level's permutation is stored. PRMPTR(i+1) - PRMPTR(i)
indicates the size of the permutation and incidentally the
size of the full, non-deflated problem.
PERM (input) INTEGER array, dimension (N lg N)
Contains the permutations (from deflation and sorting) to be
applied to each eigenblock.
GIVPTR (input) INTEGER array, dimension (N lg N)
Contains a list of pointers which indicate where in GIVCOL a
level's Givens rotations are stored. GIVPTR(i+1) - GIVPTR(i)
indicates the number of Givens rotations.
GIVCOL (input) INTEGER array, dimension (2, N lg N)
Each pair of numbers indicates a pair of columns to take place
in a Givens rotation.
GIVNUM (input) DOUBLE PRECISION array, dimension (2, N lg N)
Each number indicates the S value to be used in the
corresponding Givens rotation.
Q (input) DOUBLE PRECISION array, dimension (N**2)
Contains the square eigenblocks from previous levels, the
starting positions for blocks are given by QPTR.
QPTR (input) INTEGER array, dimension (N+2)
Contains a list of pointers which indicate where in Q an
eigenblock is stored. SQRT( QPTR(i+1) - QPTR(i) ) indicates
the size of the block.
Z (output) DOUBLE PRECISION array, dimension (N)
On output this vector contains the updating vector (the last
row of the first sub-eigenvector matrix and the first row of
the second sub-eigenvector matrix).
ZTEMP (workspace) DOUBLE PRECISION array, dimension (N)
INFO (output) INTEGER
= 0: successful exit.
< 0: if INFO = -i, the i-th argument had an illegal value.
=====================================================================
Test the input parameters.
Parameter adjustments */
/* Table of constant values */
static integer c__2 = 2;
static integer c__1 = 1;
static doublereal c_b24 = 1.;
static doublereal c_b26 = 0.;
/* System generated locals */
integer i__1, i__2, i__3;
/* Builtin functions */
integer pow_ii(integer *, integer *);
double sqrt(doublereal);
/* Local variables */
extern /* Subroutine */ int drot_(integer *, doublereal *, integer *,
doublereal *, integer *, doublereal *, doublereal *);
static integer curr, bsiz1, bsiz2, psiz1, psiz2, i, k, zptr1;
extern /* Subroutine */ int dgemv_(char *, integer *, integer *,
doublereal *, doublereal *, integer *, doublereal *, integer *,
doublereal *, doublereal *, integer *), dcopy_(integer *,
doublereal *, integer *, doublereal *, integer *), xerbla_(char *,
integer *);
static integer mid, ptr;
--ztemp;
--z;
--qptr;
--q;
givnum -= 3;
givcol -= 3;
--givptr;
--perm;
--prmptr;
/* Function Body */
*info = 0;
if (*n < 0) {
*info = -1;
}
if (*info != 0) {
i__1 = -(*info);
xerbla_("DLAEDA", &i__1);
return 0;
}
/* Quick return if possible */
if (*n == 0) {
return 0;
}
/* Determine location of first number in second half. */
mid = *n / 2 + 1;
/* Gather last/first rows of appropriate eigenblocks into center of Z
*/
ptr = 1;
/* Determine location of lowest level subproblem in the full storage
scheme */
i__1 = *curlvl - 1;
curr = ptr + *curpbm * pow_ii(&c__2, curlvl) + pow_ii(&c__2, &i__1) - 1;
/* Determine size of these matrices. We add HALF to the value of
the SQRT in case the machine underestimates one of these square
roots. */
bsiz1 = (integer) (sqrt((doublereal) (qptr[curr + 1] - qptr[curr])) + .5);
bsiz2 = (integer) (sqrt((doublereal) (qptr[curr + 2] - qptr[curr + 1])) +
.5);
i__1 = mid - bsiz1 - 1;
for (k = 1; k <= i__1; ++k) {
z[k] = 0.;
/* L10: */
}
dcopy_(&bsiz1, &q[qptr[curr] + bsiz1 - 1], &bsiz1, &z[mid - bsiz1], &c__1)
;
dcopy_(&bsiz2, &q[qptr[curr + 1]], &bsiz2, &z[mid], &c__1);
i__1 = *n;
for (k = mid + bsiz2; k <= i__1; ++k) {
z[k] = 0.;
/* L20: */
}
/* Loop thru remaining levels 1 -> CURLVL applying the Givens
rotations and permutation and then multiplying the center matrices
against the current Z. */
ptr = pow_ii(&c__2, tlvls) + 1;
i__1 = *curlvl - 1;
for (k = 1; k <= i__1; ++k) {
i__2 = *curlvl - k;
i__3 = *curlvl - k - 1;
curr = ptr + *curpbm * pow_ii(&c__2, &i__2) + pow_ii(&c__2, &i__3) -
1;
psiz1 = prmptr[curr + 1] - prmptr[curr];
psiz2 = prmptr[curr + 2] - prmptr[curr + 1];
zptr1 = mid - psiz1;
/* Apply Givens at CURR and CURR+1 */
i__2 = givptr[curr + 1] - 1;
for (i = givptr[curr]; i <= i__2; ++i) {
drot_(&c__1, &z[zptr1 + givcol[(i << 1) + 1] - 1], &c__1, &z[
zptr1 + givcol[(i << 1) + 2] - 1], &c__1, &givnum[(i << 1)
+ 1], &givnum[(i << 1) + 2]);
/* L30: */
}
i__2 = givptr[curr + 2] - 1;
for (i = givptr[curr + 1]; i <= i__2; ++i) {
drot_(&c__1, &z[mid - 1 + givcol[(i << 1) + 1]], &c__1, &z[mid -
1 + givcol[(i << 1) + 2]], &c__1, &givnum[(i << 1) + 1], &
givnum[(i << 1) + 2]);
/* L40: */
}
psiz1 = prmptr[curr + 1] - prmptr[curr];
psiz2 = prmptr[curr + 2] - prmptr[curr + 1];
i__2 = psiz1 - 1;
for (i = 0; i <= i__2; ++i) {
ztemp[i + 1] = z[zptr1 + perm[prmptr[curr] + i] - 1];
/* L50: */
}
i__2 = psiz2 - 1;
for (i = 0; i <= i__2; ++i) {
ztemp[psiz1 + i + 1] = z[mid + perm[prmptr[curr + 1] + i] - 1];
/* L60: */
}
/* Multiply Blocks at CURR and CURR+1
Determine size of these matrices. We add HALF to the value
of
the SQRT in case the machine underestimates one of these
square roots. */
bsiz1 = (integer) (sqrt((doublereal) (qptr[curr + 1] - qptr[curr])) +
.5);
bsiz2 = (integer) (sqrt((doublereal) (qptr[curr + 2] - qptr[curr + 1])
) + .5);
if (bsiz1 > 0) {
dgemv_("T", &bsiz1, &bsiz1, &c_b24, &q[qptr[curr]], &bsiz1, &
ztemp[1], &c__1, &c_b26, &z[zptr1], &c__1);
}
i__2 = psiz1 - bsiz1;
dcopy_(&i__2, &ztemp[bsiz1 + 1], &c__1, &z[zptr1 + bsiz1], &c__1);
if (bsiz2 > 0) {
dgemv_("T", &bsiz2, &bsiz2, &c_b24, &q[qptr[curr + 1]], &bsiz2, &
ztemp[psiz1 + 1], &c__1, &c_b26, &z[mid], &c__1);
}
i__2 = psiz2 - bsiz2;
dcopy_(&i__2, &ztemp[psiz1 + bsiz2 + 1], &c__1, &z[mid + bsiz2], &
c__1);
i__2 = *tlvls - k;
ptr += pow_ii(&c__2, &i__2);
/* L70: */
}
return 0;
/* End of DLAEDA */
} /* dlaeda_ */
int slaed0_(int *icompq, int *qsiz, int *n, float
*d__, float *e, float *q, int *ldq, float *qstore, int *ldqs,
float *work, int *iwork, int *info)
{
/* System generated locals */
int q_dim1, q_offset, qstore_dim1, qstore_offset, i__1, i__2;
float r__1;
/* Builtin functions */
double log(double);
int pow_ii(int *, int *);
/* Local variables */
int i__, j, k, iq, lgn, msd2, smm1, spm1, spm2;
float temp;
int curr;
extern int sgemm_(char *, char *, int *, int *,
int *, float *, float *, int *, float *, int *, float *,
float *, int *);
int iperm, indxq, iwrem;
extern int scopy_(int *, float *, int *, float *,
int *);
int iqptr, tlvls;
extern int slaed1_(int *, float *, float *, int *,
int *, float *, int *, float *, int *, int *),
slaed7_(int *, int *, int *, int *, int *,
int *, float *, float *, int *, int *, float *, int *
, float *, int *, int *, int *, int *, int *,
float *, float *, int *, int *);
int igivcl;
extern int xerbla_(char *, int *);
extern int ilaenv_(int *, char *, char *, int *, int *,
int *, int *);
int igivnm, submat;
extern int slacpy_(char *, int *, int *, float *,
int *, float *, int *);
int curprb, subpbs, igivpt, curlvl, matsiz, iprmpt, smlsiz;
extern int ssteqr_(char *, int *, float *, float *,
float *, int *, float *, int *);
/* -- LAPACK routine (version 3.2) -- */
/* Univ. of Tennessee, Univ. of California Berkeley and NAG Ltd.. */
/* November 2006 */
/* .. Scalar Arguments .. */
/* .. */
/* .. Array Arguments .. */
/* .. */
/* Purpose */
/* ======= */
/* SLAED0 computes all eigenvalues and corresponding eigenvectors of a */
/* symmetric tridiagonal matrix using the divide and conquer method. */
/* Arguments */
/* ========= */
/* ICOMPQ (input) INTEGER */
/* = 0: Compute eigenvalues only. */
/* = 1: Compute eigenvectors of original dense symmetric matrix */
/* also. On entry, Q contains the orthogonal matrix used */
/* to reduce the original matrix to tridiagonal form. */
/* = 2: Compute eigenvalues and eigenvectors of tridiagonal */
/* matrix. */
/* QSIZ (input) INTEGER */
/* The dimension of the orthogonal matrix used to reduce */
/* the full matrix to tridiagonal form. QSIZ >= N if ICOMPQ = 1. */
/* N (input) INTEGER */
/* The dimension of the symmetric tridiagonal matrix. N >= 0. */
/* D (input/output) REAL array, dimension (N) */
/* On entry, the main diagonal of the tridiagonal matrix. */
/* On exit, its eigenvalues. */
/* E (input) REAL array, dimension (N-1) */
/* The off-diagonal elements of the tridiagonal matrix. */
/* On exit, E has been destroyed. */
/* Q (input/output) REAL array, dimension (LDQ, N) */
/* On entry, Q must contain an N-by-N orthogonal matrix. */
/* If ICOMPQ = 0 Q is not referenced. */
/* If ICOMPQ = 1 On entry, Q is a subset of the columns of the */
/* orthogonal matrix used to reduce the full */
/* matrix to tridiagonal form corresponding to */
/* the subset of the full matrix which is being */
/* decomposed at this time. */
/* If ICOMPQ = 2 On entry, Q will be the identity matrix. */
/* On exit, Q contains the eigenvectors of the */
/* tridiagonal matrix. */
/* LDQ (input) INTEGER */
/* The leading dimension of the array Q. If eigenvectors are */
/* desired, then LDQ >= MAX(1,N). In any case, LDQ >= 1. */
/* QSTORE (workspace) REAL array, dimension (LDQS, N) */
/* Referenced only when ICOMPQ = 1. Used to store parts of */
/* the eigenvector matrix when the updating matrix multiplies */
/* take place. */
/* LDQS (input) INTEGER */
/* The leading dimension of the array QSTORE. If ICOMPQ = 1, */
/* then LDQS >= MAX(1,N). In any case, LDQS >= 1. */
/* WORK (workspace) REAL array, */
/* If ICOMPQ = 0 or 1, the dimension of WORK must be at least */
/* 1 + 3*N + 2*N*lg N + 2*N**2 */
/* ( lg( N ) = smallest int k */
/* such that 2^k >= N ) */
/* If ICOMPQ = 2, the dimension of WORK must be at least */
/* 4*N + N**2. */
/* IWORK (workspace) INTEGER array, */
/* If ICOMPQ = 0 or 1, the dimension of IWORK must be at least */
/* 6 + 6*N + 5*N*lg N. */
/* ( lg( N ) = smallest int k */
/* such that 2^k >= N ) */
/* If ICOMPQ = 2, the dimension of IWORK must be at least */
/* 3 + 5*N. */
/* INFO (output) INTEGER */
/* = 0: successful exit. */
/* < 0: if INFO = -i, the i-th argument had an illegal value. */
/* > 0: The algorithm failed to compute an eigenvalue while */
/* working on the submatrix lying in rows and columns */
/* INFO/(N+1) through mod(INFO,N+1). */
/* Further Details */
/* =============== */
/* Based on contributions by */
/* Jeff Rutter, Computer Science Division, University of California */
/* at Berkeley, USA */
/* ===================================================================== */
/* .. Parameters .. */
/* .. */
/* .. Local Scalars .. */
/* .. */
/* .. External Subroutines .. */
/* .. */
/* .. External Functions .. */
/* .. */
/* .. Intrinsic Functions .. */
/* .. */
/* .. Executable Statements .. */
/* Test the input parameters. */
/* Parameter adjustments */
--d__;
--e;
q_dim1 = *ldq;
q_offset = 1 + q_dim1;
q -= q_offset;
qstore_dim1 = *ldqs;
qstore_offset = 1 + qstore_dim1;
qstore -= qstore_offset;
--work;
--iwork;
/* Function Body */
*info = 0;
if (*icompq < 0 || *icompq > 2) {
*info = -1;
} else if (*icompq == 1 && *qsiz < MAX(0,*n)) {
*info = -2;
} else if (*n < 0) {
*info = -3;
} else if (*ldq < MAX(1,*n)) {
*info = -7;
} else if (*ldqs < MAX(1,*n)) {
*info = -9;
}
if (*info != 0) {
i__1 = -(*info);
xerbla_("SLAED0", &i__1);
return 0;
}
/* Quick return if possible */
if (*n == 0) {
return 0;
}
smlsiz = ilaenv_(&c__9, "SLAED0", " ", &c__0, &c__0, &c__0, &c__0);
/* Determine the size and placement of the submatrices, and save in */
/* the leading elements of IWORK. */
iwork[1] = *n;
subpbs = 1;
tlvls = 0;
L10:
if (iwork[subpbs] > smlsiz) {
for (j = subpbs; j >= 1; --j) {
iwork[j * 2] = (iwork[j] + 1) / 2;
iwork[(j << 1) - 1] = iwork[j] / 2;
/* L20: */
}
++tlvls;
subpbs <<= 1;
goto L10;
}
i__1 = subpbs;
for (j = 2; j <= i__1; ++j) {
iwork[j] += iwork[j - 1];
/* L30: */
}
/* Divide the matrix into SUBPBS submatrices of size at most SMLSIZ+1 */
/* using rank-1 modifications (cuts). */
spm1 = subpbs - 1;
i__1 = spm1;
for (i__ = 1; i__ <= i__1; ++i__) {
submat = iwork[i__] + 1;
smm1 = submat - 1;
d__[smm1] -= (r__1 = e[smm1], ABS(r__1));
d__[submat] -= (r__1 = e[smm1], ABS(r__1));
/* L40: */
}
indxq = (*n << 2) + 3;
if (*icompq != 2) {
/* Set up workspaces for eigenvalues only/accumulate new vectors */
/* routine */
temp = log((float) (*n)) / log(2.f);
lgn = (int) temp;
if (pow_ii(&c__2, &lgn) < *n) {
++lgn;
}
if (pow_ii(&c__2, &lgn) < *n) {
++lgn;
}
iprmpt = indxq + *n + 1;
iperm = iprmpt + *n * lgn;
iqptr = iperm + *n * lgn;
igivpt = iqptr + *n + 2;
igivcl = igivpt + *n * lgn;
igivnm = 1;
iq = igivnm + (*n << 1) * lgn;
/* Computing 2nd power */
i__1 = *n;
iwrem = iq + i__1 * i__1 + 1;
/* Initialize pointers */
i__1 = subpbs;
for (i__ = 0; i__ <= i__1; ++i__) {
iwork[iprmpt + i__] = 1;
iwork[igivpt + i__] = 1;
/* L50: */
}
iwork[iqptr] = 1;
}
/* Solve each submatrix eigenproblem at the bottom of the divide and */
/* conquer tree. */
curr = 0;
i__1 = spm1;
for (i__ = 0; i__ <= i__1; ++i__) {
if (i__ == 0) {
submat = 1;
matsiz = iwork[1];
} else {
submat = iwork[i__] + 1;
matsiz = iwork[i__ + 1] - iwork[i__];
}
if (*icompq == 2) {
ssteqr_("I", &matsiz, &d__[submat], &e[submat], &q[submat +
submat * q_dim1], ldq, &work[1], info);
if (*info != 0) {
goto L130;
}
} else {
ssteqr_("I", &matsiz, &d__[submat], &e[submat], &work[iq - 1 +
iwork[iqptr + curr]], &matsiz, &work[1], info);
if (*info != 0) {
goto L130;
}
if (*icompq == 1) {
sgemm_("N", "N", qsiz, &matsiz, &matsiz, &c_b23, &q[submat *
q_dim1 + 1], ldq, &work[iq - 1 + iwork[iqptr + curr]],
&matsiz, &c_b24, &qstore[submat * qstore_dim1 + 1],
ldqs);
}
/* Computing 2nd power */
i__2 = matsiz;
iwork[iqptr + curr + 1] = iwork[iqptr + curr] + i__2 * i__2;
++curr;
}
k = 1;
i__2 = iwork[i__ + 1];
for (j = submat; j <= i__2; ++j) {
iwork[indxq + j] = k;
++k;
/* L60: */
}
/* L70: */
}
/* Successively merge eigensystems of adjacent submatrices */
/* into eigensystem for the corresponding larger matrix. */
/* while ( SUBPBS > 1 ) */
curlvl = 1;
L80:
if (subpbs > 1) {
spm2 = subpbs - 2;
i__1 = spm2;
for (i__ = 0; i__ <= i__1; i__ += 2) {
if (i__ == 0) {
submat = 1;
matsiz = iwork[2];
msd2 = iwork[1];
curprb = 0;
} else {
submat = iwork[i__] + 1;
matsiz = iwork[i__ + 2] - iwork[i__];
msd2 = matsiz / 2;
++curprb;
}
/* Merge lower order eigensystems (of size MSD2 and MATSIZ - MSD2) */
/* into an eigensystem of size MATSIZ. */
/* SLAED1 is used only for the full eigensystem of a tridiagonal */
/* matrix. */
/* SLAED7 handles the cases in which eigenvalues only or eigenvalues */
/* and eigenvectors of a full symmetric matrix (which was reduced to */
/* tridiagonal form) are desired. */
if (*icompq == 2) {
slaed1_(&matsiz, &d__[submat], &q[submat + submat * q_dim1],
ldq, &iwork[indxq + submat], &e[submat + msd2 - 1], &
msd2, &work[1], &iwork[subpbs + 1], info);
} else {
slaed7_(icompq, &matsiz, qsiz, &tlvls, &curlvl, &curprb, &d__[
submat], &qstore[submat * qstore_dim1 + 1], ldqs, &
iwork[indxq + submat], &e[submat + msd2 - 1], &msd2, &
work[iq], &iwork[iqptr], &iwork[iprmpt], &iwork[iperm]
, &iwork[igivpt], &iwork[igivcl], &work[igivnm], &
work[iwrem], &iwork[subpbs + 1], info);
}
if (*info != 0) {
goto L130;
}
iwork[i__ / 2 + 1] = iwork[i__ + 2];
/* L90: */
}
subpbs /= 2;
++curlvl;
goto L80;
}
/* end while */
/* Re-merge the eigenvalues/vectors which were deflated at the final */
/* merge step. */
if (*icompq == 1) {
i__1 = *n;
for (i__ = 1; i__ <= i__1; ++i__) {
j = iwork[indxq + i__];
work[i__] = d__[j];
scopy_(qsiz, &qstore[j * qstore_dim1 + 1], &c__1, &q[i__ * q_dim1
+ 1], &c__1);
/* L100: */
}
scopy_(n, &work[1], &c__1, &d__[1], &c__1);
} else if (*icompq == 2) {
i__1 = *n;
for (i__ = 1; i__ <= i__1; ++i__) {
j = iwork[indxq + i__];
work[i__] = d__[j];
scopy_(n, &q[j * q_dim1 + 1], &c__1, &work[*n * i__ + 1], &c__1);
/* L110: */
}
scopy_(n, &work[1], &c__1, &d__[1], &c__1);
slacpy_("A", n, n, &work[*n + 1], n, &q[q_offset], ldq);
} else {
i__1 = *n;
for (i__ = 1; i__ <= i__1; ++i__) {
j = iwork[indxq + i__];
work[i__] = d__[j];
/* L120: */
}
scopy_(n, &work[1], &c__1, &d__[1], &c__1);
}
goto L140;
L130:
*info = submat * (*n + 1) + submat + matsiz - 1;
L140:
return 0;
/* End of SLAED0 */
} /* slaed0_ */
/* Subroutine */ int slasda_(integer *icompq, integer *smlsiz, integer *n,
integer *sqre, real *d__, real *e, real *u, integer *ldu, real *vt,
integer *k, real *difl, real *difr, real *z__, real *poles, integer *
givptr, integer *givcol, integer *ldgcol, integer *perm, real *givnum,
real *c__, real *s, real *work, integer *iwork, integer *info)
{
/* System generated locals */
integer givcol_dim1, givcol_offset, perm_dim1, perm_offset, difl_dim1,
difl_offset, difr_dim1, difr_offset, givnum_dim1, givnum_offset,
poles_dim1, poles_offset, u_dim1, u_offset, vt_dim1, vt_offset,
z_dim1, z_offset, i__1, i__2;
/* Builtin functions */
integer pow_ii(integer *, integer *);
/* Local variables */
integer i__, j, m, i1, ic, lf, nd, ll, nl, vf, nr, vl, im1, ncc, nlf, nrf,
vfi, iwk, vli, lvl, nru, ndb1, nlp1, lvl2, nrp1;
real beta;
integer idxq, nlvl;
real alpha;
integer inode, ndiml, ndimr, idxqi, itemp, sqrei;
extern /* Subroutine */ int scopy_(integer *, real *, integer *, real *,
integer *), slasd6_(integer *, integer *, integer *, integer *,
real *, real *, real *, real *, real *, integer *, integer *,
integer *, integer *, integer *, real *, integer *, real *, real *
, real *, real *, integer *, real *, real *, real *, integer *,
integer *);
integer nwork1, nwork2;
extern /* Subroutine */ int xerbla_(char *, integer *), slasdq_(
char *, integer *, integer *, integer *, integer *, integer *,
real *, real *, real *, integer *, real *, integer *, real *,
integer *, real *, integer *), slasdt_(integer *, integer
*, integer *, integer *, integer *, integer *, integer *),
slaset_(char *, integer *, integer *, real *, real *, real *,
integer *);
integer smlszp;
/* -- LAPACK auxiliary routine (version 3.2) -- */
/* Univ. of Tennessee, Univ. of California Berkeley and NAG Ltd.. */
/* November 2006 */
/* .. Scalar Arguments .. */
/* .. */
/* .. Array Arguments .. */
/* .. */
/* Purpose */
/* ======= */
/* Using a divide and conquer approach, SLASDA computes the singular */
/* value decomposition (SVD) of a real upper bidiagonal N-by-M matrix */
/* B with diagonal D and offdiagonal E, where M = N + SQRE. The */
/* algorithm computes the singular values in the SVD B = U * S * VT. */
/* The orthogonal matrices U and VT are optionally computed in */
/* compact form. */
/* A related subroutine, SLASD0, computes the singular values and */
/* the singular vectors in explicit form. */
/* Arguments */
/* ========= */
/* ICOMPQ (input) INTEGER */
/* Specifies whether singular vectors are to be computed */
/* in compact form, as follows */
/* = 0: Compute singular values only. */
/* = 1: Compute singular vectors of upper bidiagonal */
/* matrix in compact form. */
/* SMLSIZ (input) INTEGER */
/* The maximum size of the subproblems at the bottom of the */
/* computation tree. */
/* N (input) INTEGER */
/* The row dimension of the upper bidiagonal matrix. This is */
/* also the dimension of the main diagonal array D. */
/* SQRE (input) INTEGER */
/* Specifies the column dimension of the bidiagonal matrix. */
/* = 0: The bidiagonal matrix has column dimension M = N; */
/* = 1: The bidiagonal matrix has column dimension M = N + 1. */
/* D (input/output) REAL array, dimension ( N ) */
/* On entry D contains the main diagonal of the bidiagonal */
/* matrix. On exit D, if INFO = 0, contains its singular values. */
/* E (input) REAL array, dimension ( M-1 ) */
/* Contains the subdiagonal entries of the bidiagonal matrix. */
/* On exit, E has been destroyed. */
/* U (output) REAL array, */
/* dimension ( LDU, SMLSIZ ) if ICOMPQ = 1, and not referenced */
/* if ICOMPQ = 0. If ICOMPQ = 1, on exit, U contains the left */
/* singular vector matrices of all subproblems at the bottom */
/* level. */
/* LDU (input) INTEGER, LDU = > N. */
/* The leading dimension of arrays U, VT, DIFL, DIFR, POLES, */
/* GIVNUM, and Z. */
/* VT (output) REAL array, */
/* dimension ( LDU, SMLSIZ+1 ) if ICOMPQ = 1, and not referenced */
/* if ICOMPQ = 0. If ICOMPQ = 1, on exit, VT' contains the right */
/* singular vector matrices of all subproblems at the bottom */
/* level. */
/* K (output) INTEGER array, dimension ( N ) */
/* if ICOMPQ = 1 and dimension 1 if ICOMPQ = 0. */
/* If ICOMPQ = 1, on exit, K(I) is the dimension of the I-th */
/* secular equation on the computation tree. */
/* DIFL (output) REAL array, dimension ( LDU, NLVL ), */
/* where NLVL = floor(log_2 (N/SMLSIZ))). */
/* DIFR (output) REAL array, */
/* dimension ( LDU, 2 * NLVL ) if ICOMPQ = 1 and */
/* dimension ( N ) if ICOMPQ = 0. */
/* If ICOMPQ = 1, on exit, DIFL(1:N, I) and DIFR(1:N, 2 * I - 1) */
/* record distances between singular values on the I-th */
/* level and singular values on the (I -1)-th level, and */
/* DIFR(1:N, 2 * I ) contains the normalizing factors for */
/* the right singular vector matrix. See SLASD8 for details. */
/* Z (output) REAL array, */
/* dimension ( LDU, NLVL ) if ICOMPQ = 1 and */
/* dimension ( N ) if ICOMPQ = 0. */
/* The first K elements of Z(1, I) contain the components of */
/* the deflation-adjusted updating row vector for subproblems */
/* on the I-th level. */
/* POLES (output) REAL array, */
/* dimension ( LDU, 2 * NLVL ) if ICOMPQ = 1, and not referenced */
/* if ICOMPQ = 0. If ICOMPQ = 1, on exit, POLES(1, 2*I - 1) and */
/* POLES(1, 2*I) contain the new and old singular values */
/* involved in the secular equations on the I-th level. */
/* GIVPTR (output) INTEGER array, */
/* dimension ( N ) if ICOMPQ = 1, and not referenced if */
/* ICOMPQ = 0. If ICOMPQ = 1, on exit, GIVPTR( I ) records */
/* the number of Givens rotations performed on the I-th */
/* problem on the computation tree. */
/* GIVCOL (output) INTEGER array, */
/* dimension ( LDGCOL, 2 * NLVL ) if ICOMPQ = 1, and not */
/* referenced if ICOMPQ = 0. If ICOMPQ = 1, on exit, for each I, */
/* GIVCOL(1, 2 *I - 1) and GIVCOL(1, 2 *I) record the locations */
/* of Givens rotations performed on the I-th level on the */
/* computation tree. */
/* LDGCOL (input) INTEGER, LDGCOL = > N. */
/* The leading dimension of arrays GIVCOL and PERM. */
/* PERM (output) INTEGER array, dimension ( LDGCOL, NLVL ) */
/* if ICOMPQ = 1, and not referenced */
/* if ICOMPQ = 0. If ICOMPQ = 1, on exit, PERM(1, I) records */
/* permutations done on the I-th level of the computation tree. */
/* GIVNUM (output) REAL array, */
/* dimension ( LDU, 2 * NLVL ) if ICOMPQ = 1, and not */
/* referenced if ICOMPQ = 0. If ICOMPQ = 1, on exit, for each I, */
/* GIVNUM(1, 2 *I - 1) and GIVNUM(1, 2 *I) record the C- and S- */
/* values of Givens rotations performed on the I-th level on */
/* the computation tree. */
/* C (output) REAL array, */
/* dimension ( N ) if ICOMPQ = 1, and dimension 1 if ICOMPQ = 0. */
/* If ICOMPQ = 1 and the I-th subproblem is not square, on exit, */
/* C( I ) contains the C-value of a Givens rotation related to */
/* the right null space of the I-th subproblem. */
/* S (output) REAL array, dimension ( N ) if */
/* ICOMPQ = 1, and dimension 1 if ICOMPQ = 0. If ICOMPQ = 1 */
/* and the I-th subproblem is not square, on exit, S( I ) */
/* contains the S-value of a Givens rotation related to */
/* the right null space of the I-th subproblem. */
/* WORK (workspace) REAL array, dimension */
/* (6 * N + (SMLSIZ + 1)*(SMLSIZ + 1)). */
/* IWORK (workspace) INTEGER array, dimension (7*N). */
/* INFO (output) INTEGER */
/* = 0: successful exit. */
/* < 0: if INFO = -i, the i-th argument had an illegal value. */
/* > 0: if INFO = 1, an singular value did not converge */
/* Further Details */
/* =============== */
/* Based on contributions by */
/* Ming Gu and Huan Ren, Computer Science Division, University of */
/* California at Berkeley, USA */
/* ===================================================================== */
/* .. Parameters .. */
/* .. */
/* .. Local Scalars .. */
/* .. */
/* .. External Subroutines .. */
/* .. */
/* .. Executable Statements .. */
/* Test the input parameters. */
/* Parameter adjustments */
--d__;
--e;
givnum_dim1 = *ldu;
givnum_offset = 1 + givnum_dim1;
givnum -= givnum_offset;
poles_dim1 = *ldu;
poles_offset = 1 + poles_dim1;
poles -= poles_offset;
z_dim1 = *ldu;
z_offset = 1 + z_dim1;
z__ -= z_offset;
difr_dim1 = *ldu;
difr_offset = 1 + difr_dim1;
difr -= difr_offset;
difl_dim1 = *ldu;
difl_offset = 1 + difl_dim1;
difl -= difl_offset;
vt_dim1 = *ldu;
vt_offset = 1 + vt_dim1;
vt -= vt_offset;
u_dim1 = *ldu;
u_offset = 1 + u_dim1;
u -= u_offset;
--k;
--givptr;
perm_dim1 = *ldgcol;
perm_offset = 1 + perm_dim1;
perm -= perm_offset;
givcol_dim1 = *ldgcol;
givcol_offset = 1 + givcol_dim1;
givcol -= givcol_offset;
--c__;
--s;
--work;
--iwork;
/* Function Body */
*info = 0;
if (*icompq < 0 || *icompq > 1) {
*info = -1;
} else if (*smlsiz < 3) {
*info = -2;
} else if (*n < 0) {
*info = -3;
} else if (*sqre < 0 || *sqre > 1) {
*info = -4;
} else if (*ldu < *n + *sqre) {
*info = -8;
} else if (*ldgcol < *n) {
*info = -17;
}
if (*info != 0) {
i__1 = -(*info);
xerbla_("SLASDA", &i__1);
return 0;
}
m = *n + *sqre;
/* If the input matrix is too small, call SLASDQ to find the SVD. */
if (*n <= *smlsiz) {
if (*icompq == 0) {
slasdq_("U", sqre, n, &c__0, &c__0, &c__0, &d__[1], &e[1], &vt[
vt_offset], ldu, &u[u_offset], ldu, &u[u_offset], ldu, &
work[1], info);
} else {
slasdq_("U", sqre, n, &m, n, &c__0, &d__[1], &e[1], &vt[vt_offset]
, ldu, &u[u_offset], ldu, &u[u_offset], ldu, &work[1],
info);
}
return 0;
}
/* Book-keeping and set up the computation tree. */
inode = 1;
ndiml = inode + *n;
ndimr = ndiml + *n;
idxq = ndimr + *n;
iwk = idxq + *n;
ncc = 0;
nru = 0;
smlszp = *smlsiz + 1;
vf = 1;
vl = vf + m;
nwork1 = vl + m;
nwork2 = nwork1 + smlszp * smlszp;
slasdt_(n, &nlvl, &nd, &iwork[inode], &iwork[ndiml], &iwork[ndimr],
smlsiz);
/* for the nodes on bottom level of the tree, solve */
/* their subproblems by SLASDQ. */
ndb1 = (nd + 1) / 2;
i__1 = nd;
for (i__ = ndb1; i__ <= i__1; ++i__) {
/* IC : center row of each node */
/* NL : number of rows of left subproblem */
/* NR : number of rows of right subproblem */
/* NLF: starting row of the left subproblem */
/* NRF: starting row of the right subproblem */
i1 = i__ - 1;
ic = iwork[inode + i1];
nl = iwork[ndiml + i1];
nlp1 = nl + 1;
nr = iwork[ndimr + i1];
nlf = ic - nl;
nrf = ic + 1;
idxqi = idxq + nlf - 2;
vfi = vf + nlf - 1;
vli = vl + nlf - 1;
sqrei = 1;
if (*icompq == 0) {
slaset_("A", &nlp1, &nlp1, &c_b11, &c_b12, &work[nwork1], &smlszp);
slasdq_("U", &sqrei, &nl, &nlp1, &nru, &ncc, &d__[nlf], &e[nlf], &
work[nwork1], &smlszp, &work[nwork2], &nl, &work[nwork2],
&nl, &work[nwork2], info);
itemp = nwork1 + nl * smlszp;
scopy_(&nlp1, &work[nwork1], &c__1, &work[vfi], &c__1);
scopy_(&nlp1, &work[itemp], &c__1, &work[vli], &c__1);
} else {
slaset_("A", &nl, &nl, &c_b11, &c_b12, &u[nlf + u_dim1], ldu);
slaset_("A", &nlp1, &nlp1, &c_b11, &c_b12, &vt[nlf + vt_dim1],
ldu);
slasdq_("U", &sqrei, &nl, &nlp1, &nl, &ncc, &d__[nlf], &e[nlf], &
vt[nlf + vt_dim1], ldu, &u[nlf + u_dim1], ldu, &u[nlf +
u_dim1], ldu, &work[nwork1], info);
scopy_(&nlp1, &vt[nlf + vt_dim1], &c__1, &work[vfi], &c__1);
scopy_(&nlp1, &vt[nlf + nlp1 * vt_dim1], &c__1, &work[vli], &c__1)
;
}
if (*info != 0) {
return 0;
}
i__2 = nl;
for (j = 1; j <= i__2; ++j) {
iwork[idxqi + j] = j;
/* L10: */
}
if (i__ == nd && *sqre == 0) {
sqrei = 0;
} else {
sqrei = 1;
}
idxqi += nlp1;
vfi += nlp1;
vli += nlp1;
nrp1 = nr + sqrei;
if (*icompq == 0) {
slaset_("A", &nrp1, &nrp1, &c_b11, &c_b12, &work[nwork1], &smlszp);
slasdq_("U", &sqrei, &nr, &nrp1, &nru, &ncc, &d__[nrf], &e[nrf], &
work[nwork1], &smlszp, &work[nwork2], &nr, &work[nwork2],
&nr, &work[nwork2], info);
itemp = nwork1 + (nrp1 - 1) * smlszp;
scopy_(&nrp1, &work[nwork1], &c__1, &work[vfi], &c__1);
scopy_(&nrp1, &work[itemp], &c__1, &work[vli], &c__1);
} else {
slaset_("A", &nr, &nr, &c_b11, &c_b12, &u[nrf + u_dim1], ldu);
slaset_("A", &nrp1, &nrp1, &c_b11, &c_b12, &vt[nrf + vt_dim1],
ldu);
slasdq_("U", &sqrei, &nr, &nrp1, &nr, &ncc, &d__[nrf], &e[nrf], &
vt[nrf + vt_dim1], ldu, &u[nrf + u_dim1], ldu, &u[nrf +
u_dim1], ldu, &work[nwork1], info);
scopy_(&nrp1, &vt[nrf + vt_dim1], &c__1, &work[vfi], &c__1);
scopy_(&nrp1, &vt[nrf + nrp1 * vt_dim1], &c__1, &work[vli], &c__1)
;
}
if (*info != 0) {
return 0;
}
i__2 = nr;
for (j = 1; j <= i__2; ++j) {
iwork[idxqi + j] = j;
/* L20: */
}
/* L30: */
}
/* Now conquer each subproblem bottom-up. */
j = pow_ii(&c__2, &nlvl);
for (lvl = nlvl; lvl >= 1; --lvl) {
lvl2 = (lvl << 1) - 1;
/* Find the first node LF and last node LL on */
/* the current level LVL. */
if (lvl == 1) {
lf = 1;
ll = 1;
} else {
i__1 = lvl - 1;
lf = pow_ii(&c__2, &i__1);
ll = (lf << 1) - 1;
}
i__1 = ll;
for (i__ = lf; i__ <= i__1; ++i__) {
im1 = i__ - 1;
ic = iwork[inode + im1];
nl = iwork[ndiml + im1];
nr = iwork[ndimr + im1];
nlf = ic - nl;
nrf = ic + 1;
if (i__ == ll) {
sqrei = *sqre;
} else {
sqrei = 1;
}
vfi = vf + nlf - 1;
vli = vl + nlf - 1;
idxqi = idxq + nlf - 1;
alpha = d__[ic];
beta = e[ic];
if (*icompq == 0) {
slasd6_(icompq, &nl, &nr, &sqrei, &d__[nlf], &work[vfi], &
work[vli], &alpha, &beta, &iwork[idxqi], &perm[
perm_offset], &givptr[1], &givcol[givcol_offset],
ldgcol, &givnum[givnum_offset], ldu, &poles[
poles_offset], &difl[difl_offset], &difr[difr_offset],
&z__[z_offset], &k[1], &c__[1], &s[1], &work[nwork1],
&iwork[iwk], info);
} else {
--j;
slasd6_(icompq, &nl, &nr, &sqrei, &d__[nlf], &work[vfi], &
work[vli], &alpha, &beta, &iwork[idxqi], &perm[nlf +
lvl * perm_dim1], &givptr[j], &givcol[nlf + lvl2 *
givcol_dim1], ldgcol, &givnum[nlf + lvl2 *
givnum_dim1], ldu, &poles[nlf + lvl2 * poles_dim1], &
difl[nlf + lvl * difl_dim1], &difr[nlf + lvl2 *
difr_dim1], &z__[nlf + lvl * z_dim1], &k[j], &c__[j],
&s[j], &work[nwork1], &iwork[iwk], info);
}
if (*info != 0) {
return 0;
}
/* L40: */
}
/* L50: */
}
return 0;
/* End of SLASDA */
} /* slasda_ */
/* Main program */ int MAIN__(void)
{
/* Initialized data */
static integer nd[10] = { 120,54,49,32,4,3,2 };
/* Format strings */
static char fmt_1001[] = "(\0020N\002,i5,\002 RFFTF \002,e10.3,\002 RFF"
"TB \002,e10.3,\002 RFFTFB \002,e10.3,\002 SINT \002,e10.3,"
"\002 SINTFB \002,e10.3,\002 COST \002,e10.3/7x,\002 COSTFB "
"\002,e10.3,\002 SINQF \002,e10.3,\002 SINQB \002,e10.3,\002 SI"
"NQFB \002,e10.3,\002 COSQF \002,e10.3,\002 COSQB \002,e10.3/7x,"
"\002 COSQFB \002,e10.3,\002 DEZF \002,e10.3,\002 DEZB \002,e"
"10.3,\002 DEZFB \002,e10.3,\002 CFFTF \002,e10.3,\002 CFFTB "
" \002,e10.3/7x,\002 CFFTFB \002,e10.3)";
/* System generated locals */
integer i__1, i__2, i__3, i__4, i__5, i__6;
doublereal d__1, d__2, d__3, d__4;
doublecomplex z__1, z__2, z__3;
/* Builtin functions */
double sqrt(doublereal), sin(doublereal), cos(doublereal);
integer pow_ii(integer *, integer *);
double atan(doublereal), z_abs(doublecomplex *);
integer s_wsfe(cilist *), do_fio(integer *, char *, ftnlen), e_wsfe(void);
/* Local variables */
doublereal a[100], b[100];
integer i__, j, k, n;
doublereal w[2000], x[200], y[200], ah[100], bh[100], cf, fn, dt, pi;
doublecomplex cx[200], cy[200];
doublereal xh[200];
integer nz, nm1, np1, ns2;
doublereal arg, tfn, tpi;
integer nns;
doublereal sum, arg1, arg2;
integer ns2m;
doublereal sum1, sum2, dcfb;
integer ifac[64], modn;
doublereal rftb, rftf;
extern /* Subroutine */ void cost(integer *, doublereal *, doublereal *,
integer *), sint(integer *, doublereal *, doublereal *, integer *
);
doublereal dezb1, dezf1, sqrt2;
extern /* Subroutine */ void cfftb(integer *, doublecomplex *, doublereal
*, integer *), cfftf(integer *, doublecomplex *, doublereal *,
integer *);
doublereal dezfb;
extern /* Subroutine */ void cffti(integer *, doublereal *, integer *),
rfftb(integer *, doublereal *, doublereal *, integer *);
doublereal rftfb;
extern /* Subroutine */ void rfftf(integer *, doublereal *, doublereal *,
integer *), cosqb(integer *, doublereal *, doublereal *, integer
*), rffti(integer *, doublereal *, integer *), cosqf(integer *,
doublereal *, doublereal *, integer *), sinqb(integer *,
doublereal *, doublereal *, integer *), cosqi(integer *,
doublereal *, integer *), sinqf(integer *, doublereal *,
doublereal *, integer *), costi(integer *, doublereal *, integer
*);
doublereal azero;
extern /* Subroutine */ void sinqi(integer *, doublereal *, integer *),
sinti(integer *, doublereal *, integer *);
doublereal costt, sintt, dcfftb, dcfftf, cosqfb, costfb;
extern /* Subroutine */ void ezfftb(integer *, doublereal *, doublereal *,
doublereal *, doublereal *, doublereal *, integer *);
doublereal sinqfb;
extern /* Subroutine */ void ezfftf(integer *, doublereal *, doublereal *,
doublereal *, doublereal *, doublereal *, integer *);
doublereal sintfb;
extern /* Subroutine */ void ezffti(integer *, doublereal *, integer *);
doublereal azeroh, cosqbt, cosqft, sinqbt, sinqft;
/* Fortran I/O blocks */
static cilist io___58 = { 0, 6, 0, fmt_1001, 0 };
/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
/* VERSION 4 APRIL 1985 */
/* A TEST DRIVER FOR */
/* A PACKAGE OF FORTRAN SUBPROGRAMS FOR THE FAST FOURIER */
/* TRANSFORM OF PERIODIC AND OTHER SYMMETRIC SEQUENCES */
/* BY */
/* PAUL N SWARZTRAUBER */
/* NATIONAL CENTER FOR ATMOSPHERIC RESEARCH BOULDER,COLORADO 80307 */
/* WHICH IS SPONSORED BY THE NATIONAL SCIENCE FOUNDATION */
/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
/* THIS PROGRAM TESTS THE PACKAGE OF FAST FOURIER */
/* TRANSFORMS FOR BOTH COMPLEX AND REAL PERIODIC SEQUENCES AND */
/* CERTIAN OTHER SYMMETRIC SEQUENCES THAT ARE LISTED BELOW. */
/* 1. RFFTI INITIALIZE RFFTF AND RFFTB */
/* 2. RFFTF FORWARD TRANSFORM OF A REAL PERIODIC SEQUENCE */
/* 3. RFFTB BACKWARD TRANSFORM OF A REAL COEFFICIENT ARRAY */
/* 4. EZFFTI INITIALIZE EZFFTF AND EZFFTB */
/* 5. EZFFTF A SIMPLIFIED REAL PERIODIC FORWARD TRANSFORM */
/* 6. EZFFTB A SIMPLIFIED REAL PERIODIC BACKWARD TRANSFORM */
/* 7. SINTI INITIALIZE SINT */
/* 8. SINT SINE TRANSFORM OF A REAL ODD SEQUENCE */
/* 9. COSTI INITIALIZE COST */
/* 10. COST COSINE TRANSFORM OF A REAL EVEN SEQUENCE */
/* 11. SINQI INITIALIZE SINQF AND SINQB */
/* 12. SINQF FORWARD SINE TRANSFORM WITH ODD WAVE NUMBERS */
/* 13. SINQB UNNORMALIZED INVERSE OF SINQF */
/* 14. COSQI INITIALIZE COSQF AND COSQB */
/* 15. COSQF FORWARD COSINE TRANSFORM WITH ODD WAVE NUMBERS */
/* 16. COSQB UNNORMALIZED INVERSE OF COSQF */
/* 17. CFFTI INITIALIZE CFFTF AND CFFTB */
/* 18. CFFTF FORWARD TRANSFORM OF A COMPLEX PERIODIC SEQUENCE */
/* 19. CFFTB UNNORMALIZED INVERSE OF CFFTF */
sqrt2 = sqrt(2.0);
nns = 7;
i__1 = nns;
for (nz = 1; nz <= i__1; ++nz) {
n = nd[nz - 1];
modn = n % 2;
fn = (real) n;
tfn = fn + fn;
np1 = n + 1;
nm1 = n - 1;
i__2 = np1;
for (j = 1; j <= i__2; ++j) {
x[j - 1] = sin((real) j * sqrt2);
y[j - 1] = x[j - 1];
xh[j - 1] = x[j - 1];
/* L101: */
}
/* TEST SUBROUTINES RFFTI,RFFTF AND RFFTB */
rffti(&n, w, ifac);
pi = 3.141592653589793238462643383279502884197169399375108209749445923;
dt = (pi + pi) / fn;
ns2 = (n + 1) / 2;
if (ns2 < 2) {
goto L104;
}
i__2 = ns2;
for (k = 2; k <= i__2; ++k) {
sum1 = 0.0;
sum2 = 0.0;
arg = (real) (k - 1) * dt;
i__3 = n;
for (i__ = 1; i__ <= i__3; ++i__) {
arg1 = (real) (i__ - 1) * arg;
sum1 += x[i__ - 1] * cos(arg1);
sum2 += x[i__ - 1] * sin(arg1);
/* L102: */
}
y[(k << 1) - 3] = sum1;
y[(k << 1) - 2] = -sum2;
/* L103: */
}
L104:
sum1 = 0.0;
sum2 = 0.0;
i__2 = nm1;
for (i__ = 1; i__ <= i__2; i__ += 2) {
sum1 += x[i__ - 1];
sum2 += x[i__];
/* L105: */
}
if (modn == 1) {
sum1 += x[n - 1];
}
y[0] = sum1 + sum2;
if (modn == 0) {
y[n - 1] = sum1 - sum2;
}
rfftf(&n, x, w, ifac);
rftf = 0.0;
i__2 = n;
for (i__ = 1; i__ <= i__2; ++i__) {
/* Computing MAX */
d__2 = rftf, d__3 = (d__1 = x[i__ - 1] - y[i__ - 1], abs(d__1));
rftf = max(d__2,d__3);
x[i__ - 1] = xh[i__ - 1];
/* L106: */
}
rftf /= fn;
i__2 = n;
for (i__ = 1; i__ <= i__2; ++i__) {
sum = x[0] * 0.5;
arg = (real) (i__ - 1) * dt;
if (ns2 < 2) {
goto L108;
}
i__3 = ns2;
for (k = 2; k <= i__3; ++k) {
arg1 = (real) (k - 1) * arg;
sum = sum + x[(k << 1) - 3] * cos(arg1) - x[(k << 1) - 2] *
sin(arg1);
/* L107: */
}
L108:
if (modn == 0) {
i__3 = i__ - 1;
sum += (real) pow_ii(&c_n1, &i__3) * 0.5 * x[n - 1];
}
y[i__ - 1] = sum + sum;
/* L109: */
}
rfftb(&n, x, w, ifac);
rftb = 0.0;
i__2 = n;
for (i__ = 1; i__ <= i__2; ++i__) {
/* Computing MAX */
d__2 = rftb, d__3 = (d__1 = x[i__ - 1] - y[i__ - 1], abs(d__1));
rftb = max(d__2,d__3);
x[i__ - 1] = xh[i__ - 1];
y[i__ - 1] = xh[i__ - 1];
/* L110: */
}
rfftb(&n, y, w, ifac);
rfftf(&n, y, w, ifac);
cf = 1.0 / fn;
rftfb = 0.0;
i__2 = n;
for (i__ = 1; i__ <= i__2; ++i__) {
/* Computing MAX */
d__2 = rftfb, d__3 = (d__1 = cf * y[i__ - 1] - x[i__ - 1], abs(
d__1));
rftfb = max(d__2,d__3);
/* L111: */
}
/* TEST SUBROUTINES SINTI AND SINT */
dt = pi / fn;
i__2 = nm1;
for (i__ = 1; i__ <= i__2; ++i__) {
x[i__ - 1] = xh[i__ - 1];
/* L112: */
}
i__2 = nm1;
for (i__ = 1; i__ <= i__2; ++i__) {
y[i__ - 1] = 0.0;
arg1 = (real) i__ * dt;
i__3 = nm1;
for (k = 1; k <= i__3; ++k) {
y[i__ - 1] += x[k - 1] * sin((real) k * arg1);
/* L113: */
}
y[i__ - 1] += y[i__ - 1];
/* L114: */
}
sinti(&nm1, w, ifac);
sint(&nm1, x, w, ifac);
cf = 0.5 / fn;
sintt = 0.0;
i__2 = nm1;
for (i__ = 1; i__ <= i__2; ++i__) {
/* Computing MAX */
d__2 = sintt, d__3 = (d__1 = x[i__ - 1] - y[i__ - 1], abs(d__1));
sintt = max(d__2,d__3);
x[i__ - 1] = xh[i__ - 1];
y[i__ - 1] = x[i__ - 1];
/* L115: */
}
sintt = cf * sintt;
sint(&nm1, x, w, ifac);
sint(&nm1, x, w, ifac);
sintfb = 0.0;
i__2 = nm1;
for (i__ = 1; i__ <= i__2; ++i__) {
/* Computing MAX */
d__2 = sintfb, d__3 = (d__1 = cf * x[i__ - 1] - y[i__ - 1], abs(
d__1));
sintfb = max(d__2,d__3);
/* L116: */
}
/* TEST SUBROUTINES COSTI AND COST */
i__2 = np1;
for (i__ = 1; i__ <= i__2; ++i__) {
x[i__ - 1] = xh[i__ - 1];
/* L117: */
}
i__2 = np1;
for (i__ = 1; i__ <= i__2; ++i__) {
i__3 = i__ + 1;
y[i__ - 1] = (x[0] + (real) pow_ii(&c_n1, &i__3) * x[n]) * 0.5;
arg = (real) (i__ - 1) * dt;
i__3 = n;
for (k = 2; k <= i__3; ++k) {
y[i__ - 1] += x[k - 1] * cos((real) (k - 1) * arg);
/* L118: */
}
y[i__ - 1] += y[i__ - 1];
/* L119: */
}
costi(&np1, w, ifac);
cost(&np1, x, w, ifac);
costt = 0.0;
i__2 = np1;
for (i__ = 1; i__ <= i__2; ++i__) {
/* Computing MAX */
d__2 = costt, d__3 = (d__1 = x[i__ - 1] - y[i__ - 1], abs(d__1));
costt = max(d__2,d__3);
x[i__ - 1] = xh[i__ - 1];
y[i__ - 1] = xh[i__ - 1];
/* L120: */
}
costt = cf * costt;
cost(&np1, x, w, ifac);
cost(&np1, x, w, ifac);
costfb = 0.0;
i__2 = np1;
for (i__ = 1; i__ <= i__2; ++i__) {
/* Computing MAX */
d__2 = costfb, d__3 = (d__1 = cf * x[i__ - 1] - y[i__ - 1], abs(
d__1));
costfb = max(d__2,d__3);
/* L121: */
}
/* TEST SUBROUTINES SINQI,SINQF AND SINQB */
cf = 0.25 / fn;
i__2 = n;
for (i__ = 1; i__ <= i__2; ++i__) {
y[i__ - 1] = xh[i__ - 1];
/* L122: */
}
dt = pi / (fn + fn);
i__2 = n;
for (i__ = 1; i__ <= i__2; ++i__) {
x[i__ - 1] = 0.0;
arg = dt * (real) i__;
i__3 = n;
for (k = 1; k <= i__3; ++k) {
x[i__ - 1] += y[k - 1] * sin((real) (k + k - 1) * arg);
/* L123: */
}
x[i__ - 1] *= 4.0;
/* L124: */
}
sinqi(&n, w, ifac);
sinqb(&n, y, w, ifac);
sinqbt = 0.0;
i__2 = n;
for (i__ = 1; i__ <= i__2; ++i__) {
/* Computing MAX */
d__2 = sinqbt, d__3 = (d__1 = y[i__ - 1] - x[i__ - 1], abs(d__1));
sinqbt = max(d__2,d__3);
x[i__ - 1] = xh[i__ - 1];
/* L125: */
}
sinqbt = cf * sinqbt;
i__2 = n;
for (i__ = 1; i__ <= i__2; ++i__) {
arg = (real) (i__ + i__ - 1) * dt;
i__3 = i__ + 1;
y[i__ - 1] = (real) pow_ii(&c_n1, &i__3) * 0.5 * x[n - 1];
i__3 = nm1;
for (k = 1; k <= i__3; ++k) {
y[i__ - 1] += x[k - 1] * sin((real) k * arg);
/* L126: */
}
y[i__ - 1] += y[i__ - 1];
/* L127: */
}
sinqf(&n, x, w, ifac);
sinqft = 0.0;
i__2 = n;
for (i__ = 1; i__ <= i__2; ++i__) {
/* Computing MAX */
d__2 = sinqft, d__3 = (d__1 = x[i__ - 1] - y[i__ - 1], abs(d__1));
sinqft = max(d__2,d__3);
y[i__ - 1] = xh[i__ - 1];
x[i__ - 1] = xh[i__ - 1];
/* L128: */
}
sinqf(&n, y, w, ifac);
sinqb(&n, y, w, ifac);
sinqfb = 0.0;
i__2 = n;
for (i__ = 1; i__ <= i__2; ++i__) {
/* Computing MAX */
d__2 = sinqfb, d__3 = (d__1 = cf * y[i__ - 1] - x[i__ - 1], abs(
d__1));
sinqfb = max(d__2,d__3);
/* L129: */
}
/* TEST SUBROUTINES COSQI,COSQF AND COSQB */
i__2 = n;
for (i__ = 1; i__ <= i__2; ++i__) {
y[i__ - 1] = xh[i__ - 1];
/* L130: */
}
i__2 = n;
for (i__ = 1; i__ <= i__2; ++i__) {
x[i__ - 1] = 0.0;
arg = (real) (i__ - 1) * dt;
i__3 = n;
for (k = 1; k <= i__3; ++k) {
x[i__ - 1] += y[k - 1] * cos((real) (k + k - 1) * arg);
/* L131: */
}
x[i__ - 1] *= 4.0;
/* L132: */
}
cosqi(&n, w, ifac);
cosqb(&n, y, w, ifac);
cosqbt = 0.0;
i__2 = n;
for (i__ = 1; i__ <= i__2; ++i__) {
/* Computing MAX */
d__2 = cosqbt, d__3 = (d__1 = x[i__ - 1] - y[i__ - 1], abs(d__1));
cosqbt = max(d__2,d__3);
x[i__ - 1] = xh[i__ - 1];
/* L133: */
}
cosqbt = cf * cosqbt;
i__2 = n;
for (i__ = 1; i__ <= i__2; ++i__) {
y[i__ - 1] = x[0] * 0.5;
arg = (real) (i__ + i__ - 1) * dt;
i__3 = n;
for (k = 2; k <= i__3; ++k) {
y[i__ - 1] += x[k - 1] * cos((real) (k - 1) * arg);
/* L134: */
}
y[i__ - 1] += y[i__ - 1];
/* L135: */
}
cosqf(&n, x, w, ifac);
cosqft = 0.0;
i__2 = n;
for (i__ = 1; i__ <= i__2; ++i__) {
/* Computing MAX */
d__2 = cosqft, d__3 = (d__1 = y[i__ - 1] - x[i__ - 1], abs(d__1));
cosqft = max(d__2,d__3);
x[i__ - 1] = xh[i__ - 1];
y[i__ - 1] = xh[i__ - 1];
/* L136: */
}
cosqft = cf * cosqft;
cosqb(&n, x, w, ifac);
cosqf(&n, x, w, ifac);
cosqfb = 0.0;
i__2 = n;
for (i__ = 1; i__ <= i__2; ++i__) {
/* Computing MAX */
d__2 = cosqfb, d__3 = (d__1 = cf * x[i__ - 1] - y[i__ - 1], abs(
d__1));
cosqfb = max(d__2,d__3);
/* L137: */
}
/* TEST PROGRAMS EZFFTI,EZFFTF,EZFFTB */
ezffti(&n, w, ifac);
i__2 = n;
for (i__ = 1; i__ <= i__2; ++i__) {
x[i__ - 1] = xh[i__ - 1];
/* L138: */
}
tpi = atan(1.0) * 8.0;
dt = tpi / (real) n;
ns2 = (n + 1) / 2;
cf = 2.0 / (real) n;
ns2m = ns2 - 1;
if (ns2m <= 0) {
goto L141;
}
i__2 = ns2m;
for (k = 1; k <= i__2; ++k) {
sum1 = 0.0;
sum2 = 0.0;
arg = (real) k * dt;
i__3 = n;
for (i__ = 1; i__ <= i__3; ++i__) {
arg1 = (real) (i__ - 1) * arg;
sum1 += x[i__ - 1] * cos(arg1);
sum2 += x[i__ - 1] * sin(arg1);
/* L139: */
}
a[k - 1] = cf * sum1;
b[k - 1] = cf * sum2;
/* L140: */
}
L141:
nm1 = n - 1;
sum1 = 0.0;
sum2 = 0.0;
i__2 = nm1;
for (i__ = 1; i__ <= i__2; i__ += 2) {
sum1 += x[i__ - 1];
sum2 += x[i__];
/* L142: */
}
if (modn == 1) {
sum1 += x[n - 1];
}
azero = cf * 0.5 * (sum1 + sum2);
if (modn == 0) {
a[ns2 - 1] = cf * 0.5 * (sum1 - sum2);
}
ezfftf(&n, x, &azeroh, ah, bh, w, ifac);
dezf1 = (d__1 = azeroh - azero, abs(d__1));
if (modn == 0) {
/* Computing MAX */
d__2 = dezf1, d__3 = (d__1 = a[ns2 - 1] - ah[ns2 - 1], abs(d__1));
dezf1 = max(d__2,d__3);
}
if (ns2m <= 0) {
goto L144;
}
i__2 = ns2m;
for (i__ = 1; i__ <= i__2; ++i__) {
/* Computing MAX */
d__3 = dezf1, d__4 = (d__1 = ah[i__ - 1] - a[i__ - 1], abs(d__1)),
d__3 = max(d__3,d__4), d__4 = (d__2 = bh[i__ - 1] - b[
i__ - 1], abs(d__2));
dezf1 = max(d__3,d__4);
/* L143: */
}
L144:
ns2 = n / 2;
if (modn == 0) {
b[ns2 - 1] = 0.0;
}
i__2 = n;
for (i__ = 1; i__ <= i__2; ++i__) {
sum = azero;
arg1 = (real) (i__ - 1) * dt;
i__3 = ns2;
for (k = 1; k <= i__3; ++k) {
arg2 = (real) k * arg1;
sum = sum + a[k - 1] * cos(arg2) + b[k - 1] * sin(arg2);
/* L145: */
}
x[i__ - 1] = sum;
/* L146: */
}
ezfftb(&n, y, &azero, a, b, w, ifac);
dezb1 = 0.0;
i__2 = n;
for (i__ = 1; i__ <= i__2; ++i__) {
/* Computing MAX */
d__2 = dezb1, d__3 = (d__1 = x[i__ - 1] - y[i__ - 1], abs(d__1));
dezb1 = max(d__2,d__3);
x[i__ - 1] = xh[i__ - 1];
/* L147: */
}
ezfftf(&n, x, &azero, a, b, w, ifac);
ezfftb(&n, y, &azero, a, b, w, ifac);
dezfb = 0.0;
i__2 = n;
for (i__ = 1; i__ <= i__2; ++i__) {
/* Computing MAX */
d__2 = dezfb, d__3 = (d__1 = x[i__ - 1] - y[i__ - 1], abs(d__1));
dezfb = max(d__2,d__3);
/* L148: */
}
/* TEST CFFTI,CFFTF,CFFTB */
i__2 = n;
for (i__ = 1; i__ <= i__2; ++i__) {
i__3 = i__ - 1;
d__1 = cos(sqrt2 * (real) i__);
d__2 = sin(sqrt2 * (real) (i__ * i__));
z__1.r = d__1, z__1.i = d__2;
cx[i__3].r = z__1.r, cx[i__3].i = z__1.i;
/* L149: */
}
dt = (pi + pi) / fn;
i__2 = n;
for (i__ = 1; i__ <= i__2; ++i__) {
arg1 = -((real) (i__ - 1)) * dt;
i__3 = i__ - 1;
cy[i__3].r = 0.0, cy[i__3].i = 0.0;
i__3 = n;
for (k = 1; k <= i__3; ++k) {
arg2 = (real) (k - 1) * arg1;
i__4 = i__ - 1;
i__5 = i__ - 1;
d__1 = cos(arg2);
d__2 = sin(arg2);
z__3.r = d__1, z__3.i = d__2;
i__6 = k - 1;
z__2.r = z__3.r * cx[i__6].r - z__3.i * cx[i__6].i, z__2.i =
z__3.r * cx[i__6].i + z__3.i * cx[i__6].r;
z__1.r = cy[i__5].r + z__2.r, z__1.i = cy[i__5].i + z__2.i;
cy[i__4].r = z__1.r, cy[i__4].i = z__1.i;
/* L150: */
}
/* L151: */
}
cffti(&n, w, ifac);
cfftf(&n, cx, w, ifac);
dcfftf = 0.0;
i__2 = n;
for (i__ = 1; i__ <= i__2; ++i__) {
/* Computing MAX */
i__3 = i__ - 1;
i__4 = i__ - 1;
z__1.r = cx[i__3].r - cy[i__4].r, z__1.i = cx[i__3].i - cy[i__4]
.i;
d__1 = dcfftf, d__2 = z_abs(&z__1);
dcfftf = max(d__1,d__2);
i__3 = i__ - 1;
i__4 = i__ - 1;
z__1.r = cx[i__4].r / fn, z__1.i = cx[i__4].i / fn;
cx[i__3].r = z__1.r, cx[i__3].i = z__1.i;
/* L152: */
}
dcfftf /= fn;
i__2 = n;
for (i__ = 1; i__ <= i__2; ++i__) {
arg1 = (real) (i__ - 1) * dt;
i__3 = i__ - 1;
cy[i__3].r = 0.0, cy[i__3].i = 0.0;
i__3 = n;
for (k = 1; k <= i__3; ++k) {
arg2 = (real) (k - 1) * arg1;
i__4 = i__ - 1;
i__5 = i__ - 1;
d__1 = cos(arg2);
d__2 = sin(arg2);
z__3.r = d__1, z__3.i = d__2;
i__6 = k - 1;
z__2.r = z__3.r * cx[i__6].r - z__3.i * cx[i__6].i, z__2.i =
z__3.r * cx[i__6].i + z__3.i * cx[i__6].r;
z__1.r = cy[i__5].r + z__2.r, z__1.i = cy[i__5].i + z__2.i;
cy[i__4].r = z__1.r, cy[i__4].i = z__1.i;
/* L153: */
}
/* L154: */
}
cfftb(&n, cx, w, ifac);
dcfftb = 0.0;
i__2 = n;
for (i__ = 1; i__ <= i__2; ++i__) {
/* Computing MAX */
i__3 = i__ - 1;
i__4 = i__ - 1;
z__1.r = cx[i__3].r - cy[i__4].r, z__1.i = cx[i__3].i - cy[i__4]
.i;
d__1 = dcfftb, d__2 = z_abs(&z__1);
dcfftb = max(d__1,d__2);
i__3 = i__ - 1;
i__4 = i__ - 1;
cx[i__3].r = cy[i__4].r, cx[i__3].i = cy[i__4].i;
/* L155: */
}
cf = 1.0 / fn;
cfftf(&n, cx, w, ifac);
cfftb(&n, cx, w, ifac);
dcfb = 0.0;
i__2 = n;
for (i__ = 1; i__ <= i__2; ++i__) {
/* Computing MAX */
i__3 = i__ - 1;
z__2.r = cf * cx[i__3].r, z__2.i = cf * cx[i__3].i;
i__4 = i__ - 1;
z__1.r = z__2.r - cy[i__4].r, z__1.i = z__2.i - cy[i__4].i;
d__1 = dcfb, d__2 = z_abs(&z__1);
dcfb = max(d__1,d__2);
/* L156: */
}
s_wsfe(&io___58);
do_fio(&c__1, (char *)&n, (ftnlen)sizeof(integer));
do_fio(&c__1, (char *)&rftf, (ftnlen)sizeof(doublereal));
do_fio(&c__1, (char *)&rftb, (ftnlen)sizeof(doublereal));
do_fio(&c__1, (char *)&rftfb, (ftnlen)sizeof(doublereal));
do_fio(&c__1, (char *)&sintt, (ftnlen)sizeof(doublereal));
do_fio(&c__1, (char *)&sintfb, (ftnlen)sizeof(doublereal));
do_fio(&c__1, (char *)&costt, (ftnlen)sizeof(doublereal));
do_fio(&c__1, (char *)&costfb, (ftnlen)sizeof(doublereal));
do_fio(&c__1, (char *)&sinqft, (ftnlen)sizeof(doublereal));
do_fio(&c__1, (char *)&sinqbt, (ftnlen)sizeof(doublereal));
do_fio(&c__1, (char *)&sinqfb, (ftnlen)sizeof(doublereal));
do_fio(&c__1, (char *)&cosqft, (ftnlen)sizeof(doublereal));
do_fio(&c__1, (char *)&cosqbt, (ftnlen)sizeof(doublereal));
do_fio(&c__1, (char *)&cosqfb, (ftnlen)sizeof(doublereal));
do_fio(&c__1, (char *)&dezf1, (ftnlen)sizeof(doublereal));
do_fio(&c__1, (char *)&dezb1, (ftnlen)sizeof(doublereal));
do_fio(&c__1, (char *)&dezfb, (ftnlen)sizeof(doublereal));
do_fio(&c__1, (char *)&dcfftf, (ftnlen)sizeof(doublereal));
do_fio(&c__1, (char *)&dcfftb, (ftnlen)sizeof(doublereal));
do_fio(&c__1, (char *)&dcfb, (ftnlen)sizeof(doublereal));
e_wsfe();
/* L157: */
}
return 0;
} /* MAIN__ */
/* Subroutine */
int dlalsa_(integer *icompq, integer *smlsiz, integer *n, integer *nrhs, doublereal *b, integer *ldb, doublereal *bx, integer * ldbx, doublereal *u, integer *ldu, doublereal *vt, integer *k, doublereal *difl, doublereal *difr, doublereal *z__, doublereal * poles, integer *givptr, integer *givcol, integer *ldgcol, integer * perm, doublereal *givnum, doublereal *c__, doublereal *s, doublereal * work, integer *iwork, integer *info)
{
/* System generated locals */
integer givcol_dim1, givcol_offset, perm_dim1, perm_offset, b_dim1, b_offset, bx_dim1, bx_offset, difl_dim1, difl_offset, difr_dim1, difr_offset, givnum_dim1, givnum_offset, poles_dim1, poles_offset, u_dim1, u_offset, vt_dim1, vt_offset, z_dim1, z_offset, i__1, i__2;
/* Builtin functions */
integer pow_ii(integer *, integer *);
/* Local variables */
integer i__, j, i1, ic, lf, nd, ll, nl, nr, im1, nlf, nrf, lvl, ndb1, nlp1, lvl2, nrp1, nlvl, sqre;
extern /* Subroutine */
int dgemm_(char *, char *, integer *, integer *, integer *, doublereal *, doublereal *, integer *, doublereal *, integer *, doublereal *, doublereal *, integer *);
integer inode, ndiml, ndimr;
extern /* Subroutine */
int dcopy_(integer *, doublereal *, integer *, doublereal *, integer *), dlals0_(integer *, integer *, integer *, integer *, integer *, doublereal *, integer *, doublereal *, integer *, integer *, integer *, integer *, integer *, doublereal *, integer *, doublereal *, doublereal *, doublereal *, doublereal *, integer *, doublereal *, doublereal *, doublereal *, integer *), dlasdt_(integer *, integer *, integer *, integer *, integer *, integer *, integer *), xerbla_(char *, integer *);
/* -- LAPACK computational routine (version 3.4.2) -- */
/* -- LAPACK is a software package provided by Univ. of Tennessee, -- */
/* -- Univ. of California Berkeley, Univ. of Colorado Denver and NAG Ltd..-- */
/* September 2012 */
/* .. Scalar Arguments .. */
/* .. */
/* .. Array Arguments .. */
/* .. */
/* ===================================================================== */
/* .. Parameters .. */
/* .. */
/* .. Local Scalars .. */
/* .. */
/* .. External Subroutines .. */
/* .. */
/* .. Executable Statements .. */
/* Test the input parameters. */
/* Parameter adjustments */
b_dim1 = *ldb;
b_offset = 1 + b_dim1;
b -= b_offset;
bx_dim1 = *ldbx;
bx_offset = 1 + bx_dim1;
bx -= bx_offset;
givnum_dim1 = *ldu;
givnum_offset = 1 + givnum_dim1;
givnum -= givnum_offset;
poles_dim1 = *ldu;
poles_offset = 1 + poles_dim1;
poles -= poles_offset;
z_dim1 = *ldu;
z_offset = 1 + z_dim1;
z__ -= z_offset;
difr_dim1 = *ldu;
difr_offset = 1 + difr_dim1;
difr -= difr_offset;
difl_dim1 = *ldu;
difl_offset = 1 + difl_dim1;
difl -= difl_offset;
vt_dim1 = *ldu;
vt_offset = 1 + vt_dim1;
vt -= vt_offset;
u_dim1 = *ldu;
u_offset = 1 + u_dim1;
u -= u_offset;
--k;
--givptr;
perm_dim1 = *ldgcol;
perm_offset = 1 + perm_dim1;
perm -= perm_offset;
givcol_dim1 = *ldgcol;
givcol_offset = 1 + givcol_dim1;
givcol -= givcol_offset;
--c__;
--s;
--work;
--iwork;
/* Function Body */
*info = 0;
if (*icompq < 0 || *icompq > 1)
{
*info = -1;
}
else if (*smlsiz < 3)
{
*info = -2;
}
else if (*n < *smlsiz)
{
*info = -3;
}
else if (*nrhs < 1)
{
*info = -4;
}
else if (*ldb < *n)
{
*info = -6;
}
else if (*ldbx < *n)
{
*info = -8;
}
else if (*ldu < *n)
{
*info = -10;
}
else if (*ldgcol < *n)
{
*info = -19;
}
if (*info != 0)
{
i__1 = -(*info);
xerbla_("DLALSA", &i__1);
return 0;
}
/* Book-keeping and setting up the computation tree. */
inode = 1;
ndiml = inode + *n;
ndimr = ndiml + *n;
dlasdt_(n, &nlvl, &nd, &iwork[inode], &iwork[ndiml], &iwork[ndimr], smlsiz);
/* The following code applies back the left singular vector factors. */
/* For applying back the right singular vector factors, go to 50. */
if (*icompq == 1)
{
goto L50;
}
/* The nodes on the bottom level of the tree were solved */
/* by DLASDQ. The corresponding left and right singular vector */
/* matrices are in explicit form. First apply back the left */
/* singular vector matrices. */
ndb1 = (nd + 1) / 2;
i__1 = nd;
for (i__ = ndb1;
i__ <= i__1;
++i__)
{
/* IC : center row of each node */
/* NL : number of rows of left subproblem */
/* NR : number of rows of right subproblem */
/* NLF: starting row of the left subproblem */
/* NRF: starting row of the right subproblem */
i1 = i__ - 1;
ic = iwork[inode + i1];
nl = iwork[ndiml + i1];
nr = iwork[ndimr + i1];
nlf = ic - nl;
nrf = ic + 1;
dgemm_("T", "N", &nl, nrhs, &nl, &c_b7, &u[nlf + u_dim1], ldu, &b[nlf + b_dim1], ldb, &c_b8, &bx[nlf + bx_dim1], ldbx);
dgemm_("T", "N", &nr, nrhs, &nr, &c_b7, &u[nrf + u_dim1], ldu, &b[nrf + b_dim1], ldb, &c_b8, &bx[nrf + bx_dim1], ldbx);
/* L10: */
}
/* Next copy the rows of B that correspond to unchanged rows */
/* in the bidiagonal matrix to BX. */
i__1 = nd;
for (i__ = 1;
i__ <= i__1;
++i__)
{
ic = iwork[inode + i__ - 1];
dcopy_(nrhs, &b[ic + b_dim1], ldb, &bx[ic + bx_dim1], ldbx);
/* L20: */
}
/* Finally go through the left singular vector matrices of all */
/* the other subproblems bottom-up on the tree. */
j = pow_ii(&c__2, &nlvl);
sqre = 0;
for (lvl = nlvl;
lvl >= 1;
--lvl)
{
lvl2 = (lvl << 1) - 1;
/* find the first node LF and last node LL on */
/* the current level LVL */
if (lvl == 1)
{
lf = 1;
ll = 1;
}
else
{
i__1 = lvl - 1;
lf = pow_ii(&c__2, &i__1);
ll = (lf << 1) - 1;
}
i__1 = ll;
for (i__ = lf;
i__ <= i__1;
++i__)
{
im1 = i__ - 1;
ic = iwork[inode + im1];
nl = iwork[ndiml + im1];
nr = iwork[ndimr + im1];
nlf = ic - nl;
nrf = ic + 1;
--j;
dlals0_(icompq, &nl, &nr, &sqre, nrhs, &bx[nlf + bx_dim1], ldbx, & b[nlf + b_dim1], ldb, &perm[nlf + lvl * perm_dim1], & givptr[j], &givcol[nlf + lvl2 * givcol_dim1], ldgcol, & givnum[nlf + lvl2 * givnum_dim1], ldu, &poles[nlf + lvl2 * poles_dim1], &difl[nlf + lvl * difl_dim1], &difr[nlf + lvl2 * difr_dim1], &z__[nlf + lvl * z_dim1], &k[j], &c__[ j], &s[j], &work[1], info);
/* L30: */
}
/* L40: */
}
goto L90;
/* ICOMPQ = 1: applying back the right singular vector factors. */
L50: /* First now go through the right singular vector matrices of all */
/* the tree nodes top-down. */
j = 0;
i__1 = nlvl;
for (lvl = 1;
lvl <= i__1;
++lvl)
{
lvl2 = (lvl << 1) - 1;
/* Find the first node LF and last node LL on */
/* the current level LVL. */
if (lvl == 1)
{
lf = 1;
ll = 1;
}
else
{
i__2 = lvl - 1;
lf = pow_ii(&c__2, &i__2);
ll = (lf << 1) - 1;
}
i__2 = lf;
for (i__ = ll;
i__ >= i__2;
--i__)
{
im1 = i__ - 1;
ic = iwork[inode + im1];
nl = iwork[ndiml + im1];
nr = iwork[ndimr + im1];
nlf = ic - nl;
nrf = ic + 1;
if (i__ == ll)
{
sqre = 0;
}
else
{
sqre = 1;
}
++j;
dlals0_(icompq, &nl, &nr, &sqre, nrhs, &b[nlf + b_dim1], ldb, &bx[ nlf + bx_dim1], ldbx, &perm[nlf + lvl * perm_dim1], & givptr[j], &givcol[nlf + lvl2 * givcol_dim1], ldgcol, & givnum[nlf + lvl2 * givnum_dim1], ldu, &poles[nlf + lvl2 * poles_dim1], &difl[nlf + lvl * difl_dim1], &difr[nlf + lvl2 * difr_dim1], &z__[nlf + lvl * z_dim1], &k[j], &c__[ j], &s[j], &work[1], info);
/* L60: */
}
/* L70: */
}
/* The nodes on the bottom level of the tree were solved */
/* by DLASDQ. The corresponding right singular vector */
/* matrices are in explicit form. Apply them back. */
ndb1 = (nd + 1) / 2;
i__1 = nd;
for (i__ = ndb1;
i__ <= i__1;
++i__)
{
i1 = i__ - 1;
ic = iwork[inode + i1];
nl = iwork[ndiml + i1];
nr = iwork[ndimr + i1];
nlp1 = nl + 1;
if (i__ == nd)
{
nrp1 = nr;
}
else
{
nrp1 = nr + 1;
}
nlf = ic - nl;
nrf = ic + 1;
dgemm_("T", "N", &nlp1, nrhs, &nlp1, &c_b7, &vt[nlf + vt_dim1], ldu, & b[nlf + b_dim1], ldb, &c_b8, &bx[nlf + bx_dim1], ldbx);
dgemm_("T", "N", &nrp1, nrhs, &nrp1, &c_b7, &vt[nrf + vt_dim1], ldu, & b[nrf + b_dim1], ldb, &c_b8, &bx[nrf + bx_dim1], ldbx);
/* L80: */
}
L90:
return 0;
/* End of DLALSA */
}
/* Subroutine */ int claed0_(integer *qsiz, integer *n, real *d, real *e,
complex *q, integer *ldq, complex *qstore, integer *ldqs, real *rwork,
integer *iwork, 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
=======
Using the divide and conquer method, CLAED0 computes all eigenvalues
of a symmetric tridiagonal matrix which is one diagonal block of
those from reducing a dense or band Hermitian matrix and
corresponding eigenvectors of the dense or band matrix.
Arguments
=========
QSIZ (input) INTEGER
The dimension of the unitary matrix used to reduce
the full matrix to tridiagonal form. QSIZ >= N if ICOMPQ = 1.
N (input) INTEGER
The dimension of the symmetric tridiagonal matrix. N >= 0.
D (input/output) REAL array, dimension (N)
On entry, the diagonal elements of the tridiagonal matrix.
On exit, the eigenvalues in ascending order.
E (input/output) REAL array, dimension (N-1)
On entry, the off-diagonal elements of the tridiagonal matrix.
On exit, E has been destroyed.
Q (input/output) COMPLEX array, dimension (LDQ,N)
On entry, Q must contain an QSIZ x N matrix whose columns
unitarily orthonormal. It is a part of the unitary matrix
that reduces the full dense Hermitian matrix to a
(reducible) symmetric tridiagonal matrix.
LDQ (input) INTEGER
The leading dimension of the array Q. LDQ >= max(1,N).
IWORK (workspace) INTEGER array,
the dimension of IWORK must be at least
6 + 6*N + 5*N*lg N
( lg( N ) = smallest integer k
such that 2^k >= N )
RWORK (workspace) REAL array,
dimension (1 + 3*N + 2*N*lg N + 3*N**2)
( lg( N ) = smallest integer k
such that 2^k >= N )
QSTORE (workspace) COMPLEX array, dimension (LDQS, N)
Used to store parts of
the eigenvector matrix when the updating matrix multiplies
take place.
LDQS (input) INTEGER
The leading dimension of the array QSTORE.
LDQS >= max(1,N).
INFO (output) INTEGER
= 0: successful exit.
< 0: if INFO = -i, the i-th argument had an illegal value.
> 0: The algorithm failed to compute an eigenvalue while
working on the submatrix lying in rows and columns
INFO/(N+1) through mod(INFO,N+1).
=====================================================================
Warning: N could be as big as QSIZ!
Test the input parameters.
Parameter adjustments
Function Body */
/* Table of constant values */
static integer c__2 = 2;
static integer c__1 = 1;
/* System generated locals */
integer q_dim1, q_offset, qstore_dim1, qstore_offset, i__1, i__2;
real r__1;
/* Builtin functions */
double log(doublereal);
integer pow_ii(integer *, integer *);
/* Local variables */
static real temp;
static integer curr, i, j, k, iperm;
extern /* Subroutine */ int ccopy_(integer *, complex *, integer *,
complex *, integer *);
static integer indxq, iwrem;
extern /* Subroutine */ int scopy_(integer *, real *, integer *, real *,
integer *);
static integer iqptr;
extern /* Subroutine */ int claed7_(integer *, integer *, integer *,
integer *, integer *, integer *, real *, complex *, integer *,
real *, integer *, real *, integer *, integer *, integer *,
integer *, integer *, real *, complex *, real *, integer *,
integer *);
static integer tlvls, ll, iq;
extern /* Subroutine */ int clacrm_(integer *, integer *, complex *,
integer *, real *, integer *, complex *, integer *, real *);
static integer igivcl;
extern /* Subroutine */ int xerbla_(char *, integer *);
static integer igivnm, submat, curprb, subpbs, igivpt, curlvl, matsiz,
iprmpt;
extern /* Subroutine */ int ssteqr_(char *, integer *, real *, real *,
real *, integer *, real *, integer *);
static integer lgn, msd2, smm1, spm1, spm2;
#define D(I) d[(I)-1]
#define E(I) e[(I)-1]
#define RWORK(I) rwork[(I)-1]
#define IWORK(I) iwork[(I)-1]
#define Q(I,J) q[(I)-1 + ((J)-1)* ( *ldq)]
#define QSTORE(I,J) qstore[(I)-1 + ((J)-1)* ( *ldqs)]
*info = 0;
/* IF( ICOMPQ .LT. 0 .OR. ICOMPQ .GT. 2 ) THEN
INFO = -1
ELSE IF( ( ICOMPQ .EQ. 1 ) .AND. ( QSIZ .LT. MAX( 0, N ) ) )
$ THEN */
if (*qsiz < max(0,*n)) {
*info = -1;
} else if (*n < 0) {
*info = -2;
} else if (*ldq < max(1,*n)) {
*info = -6;
} else if (*ldqs < max(1,*n)) {
*info = -8;
}
if (*info != 0) {
i__1 = -(*info);
xerbla_("CLAED0", &i__1);
return 0;
}
/* Quick return if possible */
if (*n == 0) {
return 0;
}
/* Determine the size and placement of the submatrices, and save in
the leading elements of IWORK. */
IWORK(1) = *n;
subpbs = 1;
tlvls = 0;
L10:
if (IWORK(subpbs) > 25) {
for (j = subpbs; j >= 1; --j) {
IWORK(j * 2) = (IWORK(j) + 1) / 2;
IWORK((j << 1) - 1) = IWORK(j) / 2;
/* L20: */
}
++tlvls;
subpbs <<= 1;
goto L10;
}
i__1 = subpbs;
for (j = 2; j <= subpbs; ++j) {
IWORK(j) += IWORK(j - 1);
/* L30: */
}
/* Divide the matrix into SUBPBS submatrices of size at most SMLSIZ+1
using rank-1 modifications (cuts). */
spm1 = subpbs - 1;
i__1 = spm1;
for (i = 1; i <= spm1; ++i) {
submat = IWORK(i) + 1;
smm1 = submat - 1;
D(smm1) -= (r__1 = E(smm1), dabs(r__1));
D(submat) -= (r__1 = E(smm1), dabs(r__1));
/* L40: */
}
indxq = (*n << 2) + 3;
/* Set up workspaces for eigenvalues only/accumulate new vectors
routine */
temp = log((real) (*n)) / log(2.f);
lgn = (integer) temp;
if (pow_ii(&c__2, &lgn) < *n) {
++lgn;
}
if (pow_ii(&c__2, &lgn) < *n) {
++lgn;
}
iprmpt = indxq + *n + 1;
iperm = iprmpt + *n * lgn;
iqptr = iperm + *n * lgn;
igivpt = iqptr + *n + 2;
igivcl = igivpt + *n * lgn;
igivnm = 1;
iq = igivnm + (*n << 1) * lgn;
/* Computing 2nd power */
i__1 = *n;
iwrem = iq + i__1 * i__1 + 1;
/* Initialize pointers */
i__1 = subpbs;
for (i = 0; i <= subpbs; ++i) {
IWORK(iprmpt + i) = 1;
IWORK(igivpt + i) = 1;
/* L50: */
}
IWORK(iqptr) = 1;
/* Solve each submatrix eigenproblem at the bottom of the divide and
conquer tree. */
curr = 0;
i__1 = spm1;
for (i = 0; i <= spm1; ++i) {
if (i == 0) {
submat = 1;
matsiz = IWORK(1);
} else {
submat = IWORK(i) + 1;
matsiz = IWORK(i + 1) - IWORK(i);
}
ll = iq - 1 + IWORK(iqptr + curr);
ssteqr_("I", &matsiz, &D(submat), &E(submat), &RWORK(ll), &matsiz, &
RWORK(1), info);
clacrm_(qsiz, &matsiz, &Q(1,submat), ldq, &RWORK(ll), &
matsiz, &QSTORE(1,submat), ldqs, &RWORK(iwrem)
);
/* Computing 2nd power */
i__2 = matsiz;
IWORK(iqptr + curr + 1) = IWORK(iqptr + curr) + i__2 * i__2;
++curr;
if (*info > 0) {
*info = submat * (*n + 1) + submat + matsiz - 1;
return 0;
}
k = 1;
i__2 = IWORK(i + 1);
for (j = submat; j <= IWORK(i+1); ++j) {
IWORK(indxq + j) = k;
++k;
/* L60: */
}
/* L70: */
}
/* Successively merge eigensystems of adjacent submatrices
into eigensystem for the corresponding larger matrix.
while ( SUBPBS > 1 ) */
curlvl = 1;
L80:
if (subpbs > 1) {
spm2 = subpbs - 2;
i__1 = spm2;
for (i = 0; i <= spm2; i += 2) {
if (i == 0) {
submat = 1;
matsiz = IWORK(2);
msd2 = IWORK(1);
curprb = 0;
} else {
submat = IWORK(i) + 1;
matsiz = IWORK(i + 2) - IWORK(i);
msd2 = matsiz / 2;
++curprb;
}
/* Merge lower order eigensystems (of size MSD2 and MATSIZ - M
SD2)
into an eigensystem of size MATSIZ. CLAED7 handles the cas
e
when the eigenvectors of a full or band Hermitian matrix (w
hich
was reduced to tridiagonal form) are desired.
I am free to use Q as a valuable working space until Loop 1
50. */
claed7_(&matsiz, &msd2, qsiz, &tlvls, &curlvl, &curprb, &D(submat)
, &QSTORE(1,submat), ldqs, &E(submat +
msd2 - 1), &IWORK(indxq + submat), &RWORK(iq), &IWORK(
iqptr), &IWORK(iprmpt), &IWORK(iperm), &IWORK(igivpt), &
IWORK(igivcl), &RWORK(igivnm), &Q(1,submat), &
RWORK(iwrem), &IWORK(subpbs + 1), info);
if (*info > 0) {
*info = submat * (*n + 1) + submat + matsiz - 1;
return 0;
}
IWORK(i / 2 + 1) = IWORK(i + 2);
/* L90: */
}
subpbs /= 2;
++curlvl;
goto L80;
}
/* end while
Re-merge the eigenvalues/vectors which were deflated at the final
merge step. */
i__1 = *n;
for (i = 1; i <= *n; ++i) {
j = IWORK(indxq + i);
RWORK(i) = D(j);
ccopy_(qsiz, &QSTORE(1,j), &c__1, &Q(1,i),
&c__1);
/* L100: */
}
scopy_(n, &RWORK(1), &c__1, &D(1), &c__1);
return 0;
/* End of CLAED0 */
} /* claed0_ */
/* Subroutine */ int splicingdlasd0_(integer *n, integer *sqre, doublereal *d__,
doublereal *e, doublereal *u, integer *ldu, doublereal *vt, integer *
ldvt, integer *smlsiz, integer *iwork, doublereal *work, integer *
info)
{
/* System generated locals */
integer u_dim1, u_offset, vt_dim1, vt_offset, i__1, i__2;
/* Builtin functions */
integer pow_ii(integer *, integer *);
/* Local variables */
static integer i__, j, m, i1, ic, lf, nd, ll, nl, nr, im1, ncc, nlf, nrf,
iwk, lvl, ndb1, nlp1, nrp1;
static doublereal beta;
static integer idxq, nlvl;
static doublereal alpha;
static integer inode, ndiml, idxqc, ndimr, itemp, sqrei;
extern /* Subroutine */ int splicingdlasd1_(integer *, integer *, integer *,
doublereal *, doublereal *, doublereal *, doublereal *, integer *,
doublereal *, integer *, integer *, integer *, doublereal *,
integer *), splicingdlasdq_(char *, integer *, integer *, integer *,
integer *, integer *, doublereal *, doublereal *, doublereal *,
integer *, doublereal *, integer *, doublereal *, integer *,
doublereal *, integer *), splicingdlasdt_(integer *, integer *,
integer *, integer *, integer *, integer *, integer *), splicingxerbla_(
char *, integer *, ftnlen);
/* -- LAPACK auxiliary routine (version 3.2.2) --
-- LAPACK is a software package provided by Univ. of Tennessee, --
-- Univ. of California Berkeley, Univ. of Colorado Denver and NAG Ltd..--
June 2010
Purpose
=======
Using a divide and conquer approach, DLASD0 computes the singular
value decomposition (SVD) of a real upper bidiagonal N-by-M
matrix B with diagonal D and offdiagonal E, where M = N + SQRE.
The algorithm computes orthogonal matrices U and VT such that
B = U * S * VT. The singular values S are overwritten on D.
A related subroutine, DLASDA, computes only the singular values,
and optionally, the singular vectors in compact form.
Arguments
=========
N (input) INTEGER
On entry, the row dimension of the upper bidiagonal matrix.
This is also the dimension of the main diagonal array D.
SQRE (input) INTEGER
Specifies the column dimension of the bidiagonal matrix.
= 0: The bidiagonal matrix has column dimension M = N;
= 1: The bidiagonal matrix has column dimension M = N+1;
D (input/output) DOUBLE PRECISION array, dimension (N)
On entry D contains the main diagonal of the bidiagonal
matrix.
On exit D, if INFO = 0, contains its singular values.
E (input) DOUBLE PRECISION array, dimension (M-1)
Contains the subdiagonal entries of the bidiagonal matrix.
On exit, E has been destroyed.
U (output) DOUBLE PRECISION array, dimension at least (LDQ, N)
On exit, U contains the left singular vectors.
LDU (input) INTEGER
On entry, leading dimension of U.
VT (output) DOUBLE PRECISION array, dimension at least (LDVT, M)
On exit, VT**T contains the right singular vectors.
LDVT (input) INTEGER
On entry, leading dimension of VT.
SMLSIZ (input) INTEGER
On entry, maximum size of the subproblems at the
bottom of the computation tree.
IWORK (workspace) INTEGER work array.
Dimension must be at least (8 * N)
WORK (workspace) DOUBLE PRECISION work array.
Dimension must be at least (3 * M**2 + 2 * M)
INFO (output) INTEGER
= 0: successful exit.
< 0: if INFO = -i, the i-th argument had an illegal value.
> 0: if INFO = 1, a singular value did not converge
Further Details
===============
Based on contributions by
Ming Gu and Huan Ren, Computer Science Division, University of
California at Berkeley, USA
=====================================================================
Test the input parameters.
Parameter adjustments */
--d__;
--e;
u_dim1 = *ldu;
u_offset = 1 + u_dim1;
u -= u_offset;
vt_dim1 = *ldvt;
vt_offset = 1 + vt_dim1;
vt -= vt_offset;
--iwork;
--work;
/* Function Body */
*info = 0;
if (*n < 0) {
*info = -1;
} else if (*sqre < 0 || *sqre > 1) {
*info = -2;
}
m = *n + *sqre;
if (*ldu < *n) {
*info = -6;
} else if (*ldvt < m) {
*info = -8;
} else if (*smlsiz < 3) {
*info = -9;
}
if (*info != 0) {
i__1 = -(*info);
splicingxerbla_("DLASD0", &i__1, (ftnlen)6);
return 0;
}
/* If the input matrix is too small, call DLASDQ to find the SVD. */
if (*n <= *smlsiz) {
splicingdlasdq_("U", sqre, n, &m, n, &c__0, &d__[1], &e[1], &vt[vt_offset],
ldvt, &u[u_offset], ldu, &u[u_offset], ldu, &work[1], info);
return 0;
}
/* Set up the computation tree. */
inode = 1;
ndiml = inode + *n;
ndimr = ndiml + *n;
idxq = ndimr + *n;
iwk = idxq + *n;
splicingdlasdt_(n, &nlvl, &nd, &iwork[inode], &iwork[ndiml], &iwork[ndimr],
smlsiz);
/* For the nodes on bottom level of the tree, solve
their subproblems by DLASDQ. */
ndb1 = (nd + 1) / 2;
ncc = 0;
i__1 = nd;
for (i__ = ndb1; i__ <= i__1; ++i__) {
/* IC : center row of each node
NL : number of rows of left subproblem
NR : number of rows of right subproblem
NLF: starting row of the left subproblem
NRF: starting row of the right subproblem */
i1 = i__ - 1;
ic = iwork[inode + i1];
nl = iwork[ndiml + i1];
nlp1 = nl + 1;
nr = iwork[ndimr + i1];
nrp1 = nr + 1;
nlf = ic - nl;
nrf = ic + 1;
sqrei = 1;
splicingdlasdq_("U", &sqrei, &nl, &nlp1, &nl, &ncc, &d__[nlf], &e[nlf], &vt[
nlf + nlf * vt_dim1], ldvt, &u[nlf + nlf * u_dim1], ldu, &u[
nlf + nlf * u_dim1], ldu, &work[1], info);
if (*info != 0) {
return 0;
}
itemp = idxq + nlf - 2;
i__2 = nl;
for (j = 1; j <= i__2; ++j) {
iwork[itemp + j] = j;
/* L10: */
}
if (i__ == nd) {
sqrei = *sqre;
} else {
sqrei = 1;
}
nrp1 = nr + sqrei;
splicingdlasdq_("U", &sqrei, &nr, &nrp1, &nr, &ncc, &d__[nrf], &e[nrf], &vt[
nrf + nrf * vt_dim1], ldvt, &u[nrf + nrf * u_dim1], ldu, &u[
nrf + nrf * u_dim1], ldu, &work[1], info);
if (*info != 0) {
return 0;
}
itemp = idxq + ic;
i__2 = nr;
for (j = 1; j <= i__2; ++j) {
iwork[itemp + j - 1] = j;
/* L20: */
}
/* L30: */
}
/* Now conquer each subproblem bottom-up. */
for (lvl = nlvl; lvl >= 1; --lvl) {
/* Find the first node LF and last node LL on the
current level LVL. */
if (lvl == 1) {
lf = 1;
ll = 1;
} else {
i__1 = lvl - 1;
lf = pow_ii(&c__2, &i__1);
ll = (lf << 1) - 1;
}
i__1 = ll;
for (i__ = lf; i__ <= i__1; ++i__) {
im1 = i__ - 1;
ic = iwork[inode + im1];
nl = iwork[ndiml + im1];
nr = iwork[ndimr + im1];
nlf = ic - nl;
if (*sqre == 0 && i__ == ll) {
sqrei = *sqre;
} else {
sqrei = 1;
}
idxqc = idxq + nlf - 1;
alpha = d__[ic];
beta = e[ic];
splicingdlasd1_(&nl, &nr, &sqrei, &d__[nlf], &alpha, &beta, &u[nlf + nlf *
u_dim1], ldu, &vt[nlf + nlf * vt_dim1], ldvt, &iwork[
idxqc], &iwork[iwk], &work[1], info);
if (*info != 0) {
return 0;
}
/* L40: */
}
/* L50: */
}
return 0;
/* End of DLASD0 */
} /* splicingdlasd0_ */
/* Subroutine */ int sstedc_(char *compz, integer *n, real *d__, real *e,
real *z__, integer *ldz, real *work, integer *lwork, integer *iwork,
integer *liwork, integer *info)
{
/* System generated locals */
integer z_dim1, z_offset, i__1, i__2;
real r__1, r__2;
/* Builtin functions */
double log(doublereal);
integer pow_ii(integer *, integer *);
double sqrt(doublereal);
/* Local variables */
integer i__, j, k, m;
real p;
integer ii, lgn;
real eps, tiny;
extern logical lsame_(char *, char *);
extern /* Subroutine */ int sgemm_(char *, char *, integer *, integer *,
integer *, real *, real *, integer *, real *, integer *, real *,
real *, integer *);
integer lwmin, start;
extern /* Subroutine */ int sswap_(integer *, real *, integer *, real *,
integer *), slaed0_(integer *, integer *, integer *, real *, real
*, real *, integer *, real *, integer *, real *, integer *,
integer *);
extern doublereal slamch_(char *);
extern /* Subroutine */ int xerbla_(char *, integer *);
extern integer ilaenv_(integer *, char *, char *, integer *, integer *,
integer *, integer *);
integer finish;
extern /* Subroutine */ int slascl_(char *, integer *, integer *, real *,
real *, integer *, integer *, real *, integer *, integer *), slacpy_(char *, integer *, integer *, real *, integer *,
real *, integer *), slaset_(char *, integer *, integer *,
real *, real *, real *, integer *);
integer liwmin, icompz;
real orgnrm;
extern doublereal slanst_(char *, integer *, real *, real *);
extern /* Subroutine */ int ssterf_(integer *, real *, real *, integer *),
slasrt_(char *, integer *, real *, integer *);
logical lquery;
integer smlsiz;
extern /* Subroutine */ int ssteqr_(char *, integer *, real *, real *,
real *, integer *, real *, integer *);
integer storez, strtrw;
/* -- LAPACK driver routine (version 3.1) -- */
/* Univ. of Tennessee, Univ. of California Berkeley and NAG Ltd.. */
/* November 2006 */
/* .. Scalar Arguments .. */
/* .. */
/* .. Array Arguments .. */
/* .. */
/* Purpose */
/* ======= */
/* SSTEDC computes all eigenvalues and, optionally, eigenvectors of a */
/* symmetric tridiagonal matrix using the divide and conquer method. */
/* The eigenvectors of a full or band real symmetric matrix can also be */
/* found if SSYTRD or SSPTRD or SSBTRD has been used to reduce this */
/* matrix to tridiagonal form. */
/* This code makes very mild assumptions about floating point */
/* arithmetic. It will work on machines with a guard digit in */
/* add/subtract, or on those binary machines without guard digits */
/* which subtract like the Cray X-MP, Cray Y-MP, Cray C-90, or Cray-2. */
/* It could conceivably fail on hexadecimal or decimal machines */
/* without guard digits, but we know of none. See SLAED3 for details. */
/* Arguments */
/* ========= */
/* COMPZ (input) CHARACTER*1 */
/* = 'N': Compute eigenvalues only. */
/* = 'I': Compute eigenvectors of tridiagonal matrix also. */
/* = 'V': Compute eigenvectors of original dense symmetric */
/* matrix also. On entry, Z contains the orthogonal */
/* matrix used to reduce the original matrix to */
/* tridiagonal form. */
/* N (input) INTEGER */
/* The dimension of the symmetric tridiagonal matrix. N >= 0. */
/* D (input/output) REAL array, dimension (N) */
/* On entry, the diagonal elements of the tridiagonal matrix. */
/* On exit, if INFO = 0, the eigenvalues in ascending order. */
/* E (input/output) REAL array, dimension (N-1) */
/* On entry, the subdiagonal elements of the tridiagonal matrix. */
/* On exit, E has been destroyed. */
/* Z (input/output) REAL array, dimension (LDZ,N) */
/* On entry, if COMPZ = 'V', then Z contains the orthogonal */
/* matrix used in the reduction to tridiagonal form. */
/* On exit, if INFO = 0, then if COMPZ = 'V', Z contains the */
/* orthonormal eigenvectors of the original symmetric matrix, */
/* and if COMPZ = 'I', Z contains the orthonormal eigenvectors */
/* of the symmetric tridiagonal matrix. */
/* If COMPZ = 'N', then Z is not referenced. */
/* LDZ (input) INTEGER */
/* The leading dimension of the array Z. LDZ >= 1. */
/* If eigenvectors are desired, then LDZ >= max(1,N). */
/* WORK (workspace/output) REAL array, dimension (MAX(1,LWORK)) */
/* On exit, if INFO = 0, WORK(1) returns the optimal LWORK. */
/* LWORK (input) INTEGER */
/* The dimension of the array WORK. */
/* If COMPZ = 'N' or N <= 1 then LWORK must be at least 1. */
/* If COMPZ = 'V' and N > 1 then LWORK must be at least */
/* ( 1 + 3*N + 2*N*lg N + 3*N**2 ), */
/* where lg( N ) = smallest integer k such */
/* that 2**k >= N. */
/* If COMPZ = 'I' and N > 1 then LWORK must be at least */
/* ( 1 + 4*N + N**2 ). */
/* Note that for COMPZ = 'I' or 'V', then if N is less than or */
/* equal to the minimum divide size, usually 25, then LWORK need */
/* only be max(1,2*(N-1)). */
/* 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. */
/* IWORK (workspace/output) INTEGER array, dimension (MAX(1,LIWORK)) */
/* On exit, if INFO = 0, IWORK(1) returns the optimal LIWORK. */
/* LIWORK (input) INTEGER */
/* The dimension of the array IWORK. */
/* If COMPZ = 'N' or N <= 1 then LIWORK must be at least 1. */
/* If COMPZ = 'V' and N > 1 then LIWORK must be at least */
/* ( 6 + 6*N + 5*N*lg N ). */
/* If COMPZ = 'I' and N > 1 then LIWORK must be at least */
/* ( 3 + 5*N ). */
/* Note that for COMPZ = 'I' or 'V', then if N is less than or */
/* equal to the minimum divide size, usually 25, then LIWORK */
/* need only be 1. */
/* If LIWORK = -1, then a workspace query is assumed; the */
/* routine only calculates the optimal size of the IWORK array, */
/* returns this value as the first entry of the IWORK array, and */
/* no error message related to LIWORK is issued by XERBLA. */
/* INFO (output) INTEGER */
/* = 0: successful exit. */
/* < 0: if INFO = -i, the i-th argument had an illegal value. */
/* > 0: The algorithm failed to compute an eigenvalue while */
/* working on the submatrix lying in rows and columns */
/* INFO/(N+1) through mod(INFO,N+1). */
/* Further Details */
/* =============== */
/* Based on contributions by */
/* Jeff Rutter, Computer Science Division, University of California */
/* at Berkeley, USA */
/* Modified by Francoise Tisseur, University of Tennessee. */
/* ===================================================================== */
/* .. Parameters .. */
/* .. */
/* .. Local Scalars .. */
/* .. */
/* .. External Functions .. */
/* .. */
/* .. External Subroutines .. */
/* .. */
/* .. Intrinsic Functions .. */
/* .. */
/* .. Executable Statements .. */
/* Test the input parameters. */
/* Parameter adjustments */
--d__;
--e;
z_dim1 = *ldz;
z_offset = 1 + z_dim1;
z__ -= z_offset;
--work;
--iwork;
/* Function Body */
*info = 0;
lquery = *lwork == -1 || *liwork == -1;
if (lsame_(compz, "N")) {
icompz = 0;
} else if (lsame_(compz, "V")) {
icompz = 1;
} else if (lsame_(compz, "I")) {
icompz = 2;
} else {
icompz = -1;
}
if (icompz < 0) {
*info = -1;
} else if (*n < 0) {
*info = -2;
} else if (*ldz < 1 || icompz > 0 && *ldz < max(1,*n)) {
*info = -6;
}
if (*info == 0) {
/* Compute the workspace requirements */
smlsiz = ilaenv_(&c__9, "SSTEDC", " ", &c__0, &c__0, &c__0, &c__0);
if (*n <= 1 || icompz == 0) {
liwmin = 1;
lwmin = 1;
} else if (*n <= smlsiz) {
liwmin = 1;
lwmin = *n - 1 << 1;
} else {
lgn = (integer) (log((real) (*n)) / log(2.f));
if (pow_ii(&c__2, &lgn) < *n) {
++lgn;
}
if (pow_ii(&c__2, &lgn) < *n) {
++lgn;
}
if (icompz == 1) {
/* Computing 2nd power */
i__1 = *n;
lwmin = *n * 3 + 1 + (*n << 1) * lgn + i__1 * i__1 * 3;
liwmin = *n * 6 + 6 + *n * 5 * lgn;
} else if (icompz == 2) {
/* Computing 2nd power */
i__1 = *n;
lwmin = (*n << 2) + 1 + i__1 * i__1;
liwmin = *n * 5 + 3;
}
}
work[1] = (real) lwmin;
iwork[1] = liwmin;
if (*lwork < lwmin && ! lquery) {
*info = -8;
} else if (*liwork < liwmin && ! lquery) {
*info = -10;
}
}
if (*info != 0) {
i__1 = -(*info);
xerbla_("SSTEDC", &i__1);
return 0;
} else if (lquery) {
return 0;
}
/* Quick return if possible */
if (*n == 0) {
return 0;
}
if (*n == 1) {
if (icompz != 0) {
z__[z_dim1 + 1] = 1.f;
}
return 0;
}
/* If the following conditional clause is removed, then the routine */
/* will use the Divide and Conquer routine to compute only the */
/* eigenvalues, which requires (3N + 3N**2) real workspace and */
/* (2 + 5N + 2N lg(N)) integer workspace. */
/* Since on many architectures SSTERF is much faster than any other */
/* algorithm for finding eigenvalues only, it is used here */
/* as the default. If the conditional clause is removed, then */
/* information on the size of workspace needs to be changed. */
/* If COMPZ = 'N', use SSTERF to compute the eigenvalues. */
if (icompz == 0) {
ssterf_(n, &d__[1], &e[1], info);
goto L50;
}
/* If N is smaller than the minimum divide size (SMLSIZ+1), then */
/* solve the problem with another solver. */
if (*n <= smlsiz) {
ssteqr_(compz, n, &d__[1], &e[1], &z__[z_offset], ldz, &work[1], info);
} else {
/* If COMPZ = 'V', the Z matrix must be stored elsewhere for later */
/* use. */
if (icompz == 1) {
storez = *n * *n + 1;
} else {
storez = 1;
}
if (icompz == 2) {
slaset_("Full", n, n, &c_b17, &c_b18, &z__[z_offset], ldz);
}
/* Scale. */
orgnrm = slanst_("M", n, &d__[1], &e[1]);
if (orgnrm == 0.f) {
goto L50;
}
eps = slamch_("Epsilon");
start = 1;
/* while ( START <= N ) */
L10:
if (start <= *n) {
/* Let FINISH be the position of the next subdiagonal entry */
/* such that E( FINISH ) <= TINY or FINISH = N if no such */
/* subdiagonal exists. The matrix identified by the elements */
/* between START and FINISH constitutes an independent */
/* sub-problem. */
finish = start;
L20:
if (finish < *n) {
tiny = eps * sqrt((r__1 = d__[finish], dabs(r__1))) * sqrt((
r__2 = d__[finish + 1], dabs(r__2)));
if ((r__1 = e[finish], dabs(r__1)) > tiny) {
++finish;
goto L20;
}
}
/* (Sub) Problem determined. Compute its size and solve it. */
m = finish - start + 1;
if (m == 1) {
start = finish + 1;
goto L10;
}
if (m > smlsiz) {
/* Scale. */
orgnrm = slanst_("M", &m, &d__[start], &e[start]);
slascl_("G", &c__0, &c__0, &orgnrm, &c_b18, &m, &c__1, &d__[
start], &m, info);
i__1 = m - 1;
i__2 = m - 1;
slascl_("G", &c__0, &c__0, &orgnrm, &c_b18, &i__1, &c__1, &e[
start], &i__2, info);
if (icompz == 1) {
strtrw = 1;
} else {
strtrw = start;
}
slaed0_(&icompz, n, &m, &d__[start], &e[start], &z__[strtrw +
start * z_dim1], ldz, &work[1], n, &work[storez], &
iwork[1], info);
if (*info != 0) {
*info = (*info / (m + 1) + start - 1) * (*n + 1) + *info %
(m + 1) + start - 1;
goto L50;
}
/* Scale back. */
slascl_("G", &c__0, &c__0, &c_b18, &orgnrm, &m, &c__1, &d__[
start], &m, info);
} else {
if (icompz == 1) {
/* Since QR won't update a Z matrix which is larger than */
/* the length of D, we must solve the sub-problem in a */
/* workspace and then multiply back into Z. */
ssteqr_("I", &m, &d__[start], &e[start], &work[1], &m, &
work[m * m + 1], info);
slacpy_("A", n, &m, &z__[start * z_dim1 + 1], ldz, &work[
storez], n);
sgemm_("N", "N", n, &m, &m, &c_b18, &work[storez], n, &
work[1], &m, &c_b17, &z__[start * z_dim1 + 1],
ldz);
} else if (icompz == 2) {
ssteqr_("I", &m, &d__[start], &e[start], &z__[start +
start * z_dim1], ldz, &work[1], info);
} else {
ssterf_(&m, &d__[start], &e[start], info);
}
if (*info != 0) {
*info = start * (*n + 1) + finish;
goto L50;
}
}
start = finish + 1;
goto L10;
}
/* endwhile */
/* If the problem split any number of times, then the eigenvalues */
/* will not be properly ordered. Here we permute the eigenvalues */
/* (and the associated eigenvectors) into ascending order. */
if (m != *n) {
if (icompz == 0) {
/* Use Quick Sort */
slasrt_("I", n, &d__[1], info);
} else {
/* Use Selection Sort to minimize swaps of eigenvectors */
i__1 = *n;
for (ii = 2; ii <= i__1; ++ii) {
i__ = ii - 1;
k = i__;
p = d__[i__];
i__2 = *n;
for (j = ii; j <= i__2; ++j) {
if (d__[j] < p) {
k = j;
p = d__[j];
}
/* L30: */
}
if (k != i__) {
d__[k] = d__[i__];
d__[i__] = p;
sswap_(n, &z__[i__ * z_dim1 + 1], &c__1, &z__[k *
z_dim1 + 1], &c__1);
}
/* L40: */
}
}
}
}
L50:
work[1] = (real) lwmin;
iwork[1] = liwmin;
return 0;
/* End of SSTEDC */
} /* sstedc_ */
/* Subroutine */ int dlaed7_(integer *icompq, integer *n, integer *qsiz,
integer *tlvls, integer *curlvl, integer *curpbm, doublereal *d__,
doublereal *q, integer *ldq, integer *indxq, doublereal *rho, integer
*cutpnt, doublereal *qstore, integer *qptr, integer *prmptr, integer *
perm, integer *givptr, integer *givcol, doublereal *givnum,
doublereal *work, integer *iwork, 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
=======
DLAED7 computes the updated eigensystem of a diagonal
matrix after modification by a rank-one symmetric matrix. This
routine is used only for the eigenproblem which requires all
eigenvalues and optionally eigenvectors of a dense symmetric matrix
that has been reduced to tridiagonal form. DLAED1 handles
the case in which all eigenvalues and eigenvectors of a symmetric
tridiagonal matrix are desired.
T = Q(in) ( D(in) + RHO * Z*Z' ) Q'(in) = Q(out) * D(out) * Q'(out)
where Z = Q'u, u is a vector of length N with ones in the
CUTPNT and CUTPNT + 1 th elements and zeros elsewhere.
The eigenvectors of the original matrix are stored in Q, and the
eigenvalues are in D. The algorithm consists of three stages:
The first stage consists of deflating the size of the problem
when there are multiple eigenvalues or if there is a zero in
the Z vector. For each such occurence the dimension of the
secular equation problem is reduced by one. This stage is
performed by the routine DLAED8.
The second stage consists of calculating the updated
eigenvalues. This is done by finding the roots of the secular
equation via the routine DLAED4 (as called by DLAED9).
This routine also calculates the eigenvectors of the current
problem.
The final stage consists of computing the updated eigenvectors
directly using the updated eigenvalues. The eigenvectors for
the current problem are multiplied with the eigenvectors from
the overall problem.
Arguments
=========
ICOMPQ (input) INTEGER
= 0: Compute eigenvalues only.
= 1: Compute eigenvectors of original dense symmetric matrix
also. On entry, Q contains the orthogonal matrix used
to reduce the original matrix to tridiagonal form.
N (input) INTEGER
The dimension of the symmetric tridiagonal matrix. N >= 0.
QSIZ (input) INTEGER
The dimension of the orthogonal matrix used to reduce
the full matrix to tridiagonal form. QSIZ >= N if ICOMPQ = 1.
TLVLS (input) INTEGER
The total number of merging levels in the overall divide and
conquer tree.
CURLVL (input) INTEGER
The current level in the overall merge routine,
0 <= CURLVL <= TLVLS.
CURPBM (input) INTEGER
The current problem in the current level in the overall
merge routine (counting from upper left to lower right).
D (input/output) DOUBLE PRECISION array, dimension (N)
On entry, the eigenvalues of the rank-1-perturbed matrix.
On exit, the eigenvalues of the repaired matrix.
Q (input/output) DOUBLE PRECISION array, dimension (LDQ, N)
On entry, the eigenvectors of the rank-1-perturbed matrix.
On exit, the eigenvectors of the repaired tridiagonal matrix.
LDQ (input) INTEGER
The leading dimension of the array Q. LDQ >= max(1,N).
INDXQ (output) INTEGER array, dimension (N)
The permutation which will reintegrate the subproblem just
solved back into sorted order, i.e., D( INDXQ( I = 1, N ) )
will be in ascending order.
RHO (input) DOUBLE PRECISION
The subdiagonal element used to create the rank-1
modification.
CUTPNT (input) INTEGER
Contains the location of the last eigenvalue in the leading
sub-matrix. min(1,N) <= CUTPNT <= N.
QSTORE (input/output) DOUBLE PRECISION array, dimension (N**2+1)
Stores eigenvectors of submatrices encountered during
divide and conquer, packed together. QPTR points to
beginning of the submatrices.
QPTR (input/output) INTEGER array, dimension (N+2)
List of indices pointing to beginning of submatrices stored
in QSTORE. The submatrices are numbered starting at the
bottom left of the divide and conquer tree, from left to
right and bottom to top.
PRMPTR (input) INTEGER array, dimension (N lg N)
Contains a list of pointers which indicate where in PERM a
level's permutation is stored. PRMPTR(i+1) - PRMPTR(i)
indicates the size of the permutation and also the size of
the full, non-deflated problem.
PERM (input) INTEGER array, dimension (N lg N)
Contains the permutations (from deflation and sorting) to be
applied to each eigenblock.
GIVPTR (input) INTEGER array, dimension (N lg N)
Contains a list of pointers which indicate where in GIVCOL a
level's Givens rotations are stored. GIVPTR(i+1) - GIVPTR(i)
indicates the number of Givens rotations.
GIVCOL (input) INTEGER array, dimension (2, N lg N)
Each pair of numbers indicates a pair of columns to take place
in a Givens rotation.
GIVNUM (input) DOUBLE PRECISION array, dimension (2, N lg N)
Each number indicates the S value to be used in the
corresponding Givens rotation.
WORK (workspace) DOUBLE PRECISION array, dimension (3*N+QSIZ*N)
IWORK (workspace) INTEGER array, dimension (4*N)
INFO (output) INTEGER
= 0: successful exit.
< 0: if INFO = -i, the i-th argument had an illegal value.
> 0: if INFO = 1, an eigenvalue did not converge
Further Details
===============
Based on contributions by
Jeff Rutter, Computer Science Division, University of California
at Berkeley, USA
=====================================================================
Test the input parameters.
Parameter adjustments */
/* Table of constant values */
static integer c__2 = 2;
static integer c__1 = 1;
static doublereal c_b10 = 1.;
static doublereal c_b11 = 0.;
static integer c_n1 = -1;
/* System generated locals */
integer q_dim1, q_offset, i__1, i__2;
/* Builtin functions */
integer pow_ii(integer *, integer *);
/* Local variables */
static integer indx, curr, i__, k;
extern /* Subroutine */ int dgemm_(char *, char *, integer *, integer *,
integer *, doublereal *, doublereal *, integer *, doublereal *,
integer *, doublereal *, doublereal *, integer *);
static integer indxc, indxp, n1, n2;
extern /* Subroutine */ int dlaed8_(integer *, integer *, integer *,
integer *, doublereal *, doublereal *, integer *, integer *,
doublereal *, integer *, doublereal *, doublereal *, doublereal *,
integer *, doublereal *, integer *, integer *, integer *,
doublereal *, integer *, integer *, integer *), dlaed9_(integer *,
integer *, integer *, integer *, doublereal *, doublereal *,
integer *, doublereal *, doublereal *, doublereal *, doublereal *,
integer *, integer *), dlaeda_(integer *, integer *, integer *,
integer *, integer *, integer *, integer *, integer *, doublereal
*, doublereal *, integer *, doublereal *, doublereal *, integer *)
;
static integer idlmda, is, iw, iz;
extern /* Subroutine */ int dlamrg_(integer *, integer *, doublereal *,
integer *, integer *, integer *), xerbla_(char *, integer *);
static integer coltyp, iq2, ptr, ldq2;
#define givcol_ref(a_1,a_2) givcol[(a_2)*2 + a_1]
#define givnum_ref(a_1,a_2) givnum[(a_2)*2 + a_1]
--d__;
q_dim1 = *ldq;
q_offset = 1 + q_dim1 * 1;
q -= q_offset;
--indxq;
--qstore;
--qptr;
--prmptr;
--perm;
--givptr;
givcol -= 3;
givnum -= 3;
--work;
--iwork;
/* Function Body */
*info = 0;
if (*icompq < 0 || *icompq > 1) {
*info = -1;
} else if (*n < 0) {
*info = -2;
} else if (*icompq == 1 && *qsiz < *n) {
*info = -4;
} else if (*ldq < max(1,*n)) {
*info = -9;
} else if (min(1,*n) > *cutpnt || *n < *cutpnt) {
*info = -12;
}
if (*info != 0) {
i__1 = -(*info);
xerbla_("DLAED7", &i__1);
return 0;
}
/* Quick return if possible */
if (*n == 0) {
return 0;
}
/* The following values are for bookkeeping purposes only. They are
integer pointers which indicate the portion of the workspace
used by a particular array in DLAED8 and DLAED9. */
if (*icompq == 1) {
ldq2 = *qsiz;
} else {
ldq2 = *n;
}
iz = 1;
idlmda = iz + *n;
iw = idlmda + *n;
iq2 = iw + *n;
is = iq2 + *n * ldq2;
indx = 1;
indxc = indx + *n;
coltyp = indxc + *n;
indxp = coltyp + *n;
/* Form the z-vector which consists of the last row of Q_1 and the
first row of Q_2. */
ptr = pow_ii(&c__2, tlvls) + 1;
i__1 = *curlvl - 1;
for (i__ = 1; i__ <= i__1; ++i__) {
i__2 = *tlvls - i__;
ptr += pow_ii(&c__2, &i__2);
/* L10: */
}
curr = ptr + *curpbm;
dlaeda_(n, tlvls, curlvl, curpbm, &prmptr[1], &perm[1], &givptr[1], &
givcol[3], &givnum[3], &qstore[1], &qptr[1], &work[iz], &work[iz
+ *n], info);
/* When solving the final problem, we no longer need the stored data,
so we will overwrite the data from this level onto the previously
used storage space. */
if (*curlvl == *tlvls) {
qptr[curr] = 1;
prmptr[curr] = 1;
givptr[curr] = 1;
}
/* Sort and Deflate eigenvalues. */
dlaed8_(icompq, &k, n, qsiz, &d__[1], &q[q_offset], ldq, &indxq[1], rho,
cutpnt, &work[iz], &work[idlmda], &work[iq2], &ldq2, &work[iw], &
perm[prmptr[curr]], &givptr[curr + 1], &givcol_ref(1, givptr[curr]
), &givnum_ref(1, givptr[curr]), &iwork[indxp], &iwork[indx],
info);
prmptr[curr + 1] = prmptr[curr] + *n;
givptr[curr + 1] += givptr[curr];
/* Solve Secular Equation. */
if (k != 0) {
dlaed9_(&k, &c__1, &k, n, &d__[1], &work[is], &k, rho, &work[idlmda],
&work[iw], &qstore[qptr[curr]], &k, info);
if (*info != 0) {
goto L30;
}
if (*icompq == 1) {
dgemm_("N", "N", qsiz, &k, &k, &c_b10, &work[iq2], &ldq2, &qstore[
qptr[curr]], &k, &c_b11, &q[q_offset], ldq);
}
/* Computing 2nd power */
i__1 = k;
qptr[curr + 1] = qptr[curr] + i__1 * i__1;
/* Prepare the INDXQ sorting permutation. */
n1 = k;
n2 = *n - k;
dlamrg_(&n1, &n2, &d__[1], &c__1, &c_n1, &indxq[1]);
} else {
qptr[curr + 1] = qptr[curr];
i__1 = *n;
for (i__ = 1; i__ <= i__1; ++i__) {
indxq[i__] = i__;
/* L20: */
}
}
L30:
return 0;
/* End of DLAED7 */
} /* dlaed7_ */
/* Subroutine */ int sstedc_(char *compz, integer *n, real *d__, real *e,
real *z__, integer *ldz, real *work, integer *lwork, integer *iwork,
integer *liwork, integer *info)
{
/* -- LAPACK driver 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
=======
SSTEDC computes all eigenvalues and, optionally, eigenvectors of a
symmetric tridiagonal matrix using the divide and conquer method.
The eigenvectors of a full or band real symmetric matrix can also be
found if SSYTRD or SSPTRD or SSBTRD has been used to reduce this
matrix to tridiagonal form.
This code makes very mild assumptions about floating point
arithmetic. It will work on machines with a guard digit in
add/subtract, or on those binary machines without guard digits
which subtract like the Cray X-MP, Cray Y-MP, Cray C-90, or Cray-2.
It could conceivably fail on hexadecimal or decimal machines
without guard digits, but we know of none. See SLAED3 for details.
Arguments
=========
COMPZ (input) CHARACTER*1
= 'N': Compute eigenvalues only.
= 'I': Compute eigenvectors of tridiagonal matrix also.
= 'V': Compute eigenvectors of original dense symmetric
matrix also. On entry, Z contains the orthogonal
matrix used to reduce the original matrix to
tridiagonal form.
N (input) INTEGER
The dimension of the symmetric tridiagonal matrix. N >= 0.
D (input/output) REAL array, dimension (N)
On entry, the diagonal elements of the tridiagonal matrix.
On exit, if INFO = 0, the eigenvalues in ascending order.
E (input/output) REAL array, dimension (N-1)
On entry, the subdiagonal elements of the tridiagonal matrix.
On exit, E has been destroyed.
Z (input/output) REAL array, dimension (LDZ,N)
On entry, if COMPZ = 'V', then Z contains the orthogonal
matrix used in the reduction to tridiagonal form.
On exit, if INFO = 0, then if COMPZ = 'V', Z contains the
orthonormal eigenvectors of the original symmetric matrix,
and if COMPZ = 'I', Z contains the orthonormal eigenvectors
of the symmetric tridiagonal matrix.
If COMPZ = 'N', then Z is not referenced.
LDZ (input) INTEGER
The leading dimension of the array Z. LDZ >= 1.
If eigenvectors are desired, then LDZ >= max(1,N).
WORK (workspace/output) REAL array,
dimension (LWORK)
On exit, if INFO = 0, WORK(1) returns the optimal LWORK.
LWORK (input) INTEGER
The dimension of the array WORK.
If COMPZ = 'N' or N <= 1 then LWORK must be at least 1.
If COMPZ = 'V' and N > 1 then LWORK must be at least
( 1 + 3*N + 2*N*lg N + 3*N**2 ),
where lg( N ) = smallest integer k such
that 2**k >= N.
If COMPZ = 'I' and N > 1 then LWORK must be at least
( 1 + 4*N + N**2 ).
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.
IWORK (workspace/output) INTEGER array, dimension (LIWORK)
On exit, if INFO = 0, IWORK(1) returns the optimal LIWORK.
LIWORK (input) INTEGER
The dimension of the array IWORK.
If COMPZ = 'N' or N <= 1 then LIWORK must be at least 1.
If COMPZ = 'V' and N > 1 then LIWORK must be at least
( 6 + 6*N + 5*N*lg N ).
If COMPZ = 'I' and N > 1 then LIWORK must be at least
( 3 + 5*N ).
If LIWORK = -1, then a workspace query is assumed; the
routine only calculates the optimal size of the IWORK array,
returns this value as the first entry of the IWORK array, and
no error message related to LIWORK is issued by XERBLA.
INFO (output) INTEGER
= 0: successful exit.
< 0: if INFO = -i, the i-th argument had an illegal value.
> 0: The algorithm failed to compute an eigenvalue while
working on the submatrix lying in rows and columns
INFO/(N+1) through mod(INFO,N+1).
Further Details
===============
Based on contributions by
Jeff Rutter, Computer Science Division, University of California
at Berkeley, USA
Modified by Francoise Tisseur, University of Tennessee.
=====================================================================
Test the input parameters.
Parameter adjustments */
/* Table of constant values */
static integer c__2 = 2;
static integer c__9 = 9;
static integer c__0 = 0;
static real c_b18 = 0.f;
static real c_b19 = 1.f;
static integer c__1 = 1;
/* System generated locals */
integer z_dim1, z_offset, i__1, i__2;
real r__1, r__2;
/* Builtin functions */
double log(doublereal);
integer pow_ii(integer *, integer *);
double sqrt(doublereal);
/* Local variables */
static real tiny;
static integer i__, j, k, m;
static real p;
extern logical lsame_(char *, char *);
extern /* Subroutine */ int sgemm_(char *, char *, integer *, integer *,
integer *, real *, real *, integer *, real *, integer *, real *,
real *, integer *);
static integer lwmin, start;
extern /* Subroutine */ int sswap_(integer *, real *, integer *, real *,
integer *), slaed0_(integer *, integer *, integer *, real *, real
*, real *, integer *, real *, integer *, real *, integer *,
integer *);
static integer ii;
extern doublereal slamch_(char *);
extern /* Subroutine */ int xerbla_(char *, integer *);
extern integer ilaenv_(integer *, char *, char *, integer *, integer *,
integer *, integer *, ftnlen, ftnlen);
extern /* Subroutine */ int slascl_(char *, integer *, integer *, real *,
real *, integer *, integer *, real *, integer *, integer *), slacpy_(char *, integer *, integer *, real *, integer *,
real *, integer *), slaset_(char *, integer *, integer *,
real *, real *, real *, integer *);
static integer liwmin, icompz;
static real orgnrm;
extern doublereal slanst_(char *, integer *, real *, real *);
extern /* Subroutine */ int ssterf_(integer *, real *, real *, integer *),
slasrt_(char *, integer *, real *, integer *);
static logical lquery;
static integer smlsiz;
extern /* Subroutine */ int ssteqr_(char *, integer *, real *, real *,
real *, integer *, real *, integer *);
static integer storez, strtrw, end, lgn;
static real eps;
#define z___ref(a_1,a_2) z__[(a_2)*z_dim1 + a_1]
--d__;
--e;
z_dim1 = *ldz;
z_offset = 1 + z_dim1 * 1;
z__ -= z_offset;
--work;
--iwork;
/* Function Body */
*info = 0;
lquery = *lwork == -1 || *liwork == -1;
if (lsame_(compz, "N")) {
icompz = 0;
} else if (lsame_(compz, "V")) {
icompz = 1;
} else if (lsame_(compz, "I")) {
icompz = 2;
} else {
icompz = -1;
}
if (*n <= 1 || icompz <= 0) {
liwmin = 1;
lwmin = 1;
} else {
lgn = (integer) (log((real) (*n)) / log(2.f));
if (pow_ii(&c__2, &lgn) < *n) {
++lgn;
}
if (pow_ii(&c__2, &lgn) < *n) {
++lgn;
}
if (icompz == 1) {
/* Computing 2nd power */
i__1 = *n;
lwmin = *n * 3 + 1 + (*n << 1) * lgn + i__1 * i__1 * 3;
liwmin = *n * 6 + 6 + *n * 5 * lgn;
} else if (icompz == 2) {
/* Computing 2nd power */
i__1 = *n;
lwmin = (*n << 2) + 1 + i__1 * i__1;
liwmin = *n * 5 + 3;
}
}
if (icompz < 0) {
*info = -1;
} else if (*n < 0) {
*info = -2;
} else if (*ldz < 1 || icompz > 0 && *ldz < max(1,*n)) {
*info = -6;
} else if (*lwork < lwmin && ! lquery) {
*info = -8;
} else if (*liwork < liwmin && ! lquery) {
*info = -10;
}
if (*info == 0) {
work[1] = (real) lwmin;
iwork[1] = liwmin;
}
if (*info != 0) {
i__1 = -(*info);
xerbla_("SSTEDC", &i__1);
return 0;
} else if (lquery) {
return 0;
}
/* Quick return if possible */
if (*n == 0) {
return 0;
}
if (*n == 1) {
if (icompz != 0) {
z___ref(1, 1) = 1.f;
}
return 0;
}
smlsiz = ilaenv_(&c__9, "SSTEDC", " ", &c__0, &c__0, &c__0, &c__0, (
ftnlen)6, (ftnlen)1);
/* If the following conditional clause is removed, then the routine
will use the Divide and Conquer routine to compute only the
eigenvalues, which requires (3N + 3N**2) real workspace and
(2 + 5N + 2N lg(N)) integer workspace.
Since on many architectures SSTERF is much faster than any other
algorithm for finding eigenvalues only, it is used here
as the default.
If COMPZ = 'N', use SSTERF to compute the eigenvalues. */
if (icompz == 0) {
ssterf_(n, &d__[1], &e[1], info);
return 0;
}
/* If N is smaller than the minimum divide size (SMLSIZ+1), then
solve the problem with another solver. */
if (*n <= smlsiz) {
if (icompz == 0) {
ssterf_(n, &d__[1], &e[1], info);
return 0;
} else if (icompz == 2) {
ssteqr_("I", n, &d__[1], &e[1], &z__[z_offset], ldz, &work[1],
info);
return 0;
} else {
ssteqr_("V", n, &d__[1], &e[1], &z__[z_offset], ldz, &work[1],
info);
return 0;
}
}
/* If COMPZ = 'V', the Z matrix must be stored elsewhere for later
use. */
if (icompz == 1) {
storez = *n * *n + 1;
} else {
storez = 1;
}
if (icompz == 2) {
slaset_("Full", n, n, &c_b18, &c_b19, &z__[z_offset], ldz);
}
/* Scale. */
orgnrm = slanst_("M", n, &d__[1], &e[1]);
if (orgnrm == 0.f) {
return 0;
}
eps = slamch_("Epsilon");
start = 1;
/* while ( START <= N ) */
L10:
if (start <= *n) {
/* Let END be the position of the next subdiagonal entry such that
E( END ) <= TINY or END = N if no such subdiagonal exists. The
matrix identified by the elements between START and END
constitutes an independent sub-problem. */
end = start;
L20:
if (end < *n) {
tiny = eps * sqrt((r__1 = d__[end], dabs(r__1))) * sqrt((r__2 =
d__[end + 1], dabs(r__2)));
if ((r__1 = e[end], dabs(r__1)) > tiny) {
++end;
goto L20;
}
}
/* (Sub) Problem determined. Compute its size and solve it. */
m = end - start + 1;
if (m == 1) {
start = end + 1;
goto L10;
}
if (m > smlsiz) {
*info = smlsiz;
/* Scale. */
orgnrm = slanst_("M", &m, &d__[start], &e[start]);
slascl_("G", &c__0, &c__0, &orgnrm, &c_b19, &m, &c__1, &d__[start]
, &m, info);
i__1 = m - 1;
i__2 = m - 1;
slascl_("G", &c__0, &c__0, &orgnrm, &c_b19, &i__1, &c__1, &e[
start], &i__2, info);
if (icompz == 1) {
strtrw = 1;
} else {
strtrw = start;
}
slaed0_(&icompz, n, &m, &d__[start], &e[start], &z___ref(strtrw,
start), ldz, &work[1], n, &work[storez], &iwork[1], info);
if (*info != 0) {
*info = (*info / (m + 1) + start - 1) * (*n + 1) + *info % (m
+ 1) + start - 1;
return 0;
}
/* Scale back. */
slascl_("G", &c__0, &c__0, &c_b19, &orgnrm, &m, &c__1, &d__[start]
, &m, info);
} else {
if (icompz == 1) {
/* Since QR won't update a Z matrix which is larger than the
length of D, we must solve the sub-problem in a workspace and
then multiply back into Z. */
ssteqr_("I", &m, &d__[start], &e[start], &work[1], &m, &work[
m * m + 1], info);
slacpy_("A", n, &m, &z___ref(1, start), ldz, &work[storez], n);
sgemm_("N", "N", n, &m, &m, &c_b19, &work[storez], ldz, &work[
1], &m, &c_b18, &z___ref(1, start), ldz);
} else if (icompz == 2) {
ssteqr_("I", &m, &d__[start], &e[start], &z___ref(start,
start), ldz, &work[1], info);
} else {
ssterf_(&m, &d__[start], &e[start], info);
}
if (*info != 0) {
*info = start * (*n + 1) + end;
return 0;
}
}
start = end + 1;
goto L10;
}
/* endwhile
If the problem split any number of times, then the eigenvalues
will not be properly ordered. Here we permute the eigenvalues
(and the associated eigenvectors) into ascending order. */
if (m != *n) {
if (icompz == 0) {
/* Use Quick Sort */
slasrt_("I", n, &d__[1], info);
} else {
/* Use Selection Sort to minimize swaps of eigenvectors */
i__1 = *n;
for (ii = 2; ii <= i__1; ++ii) {
i__ = ii - 1;
k = i__;
p = d__[i__];
i__2 = *n;
for (j = ii; j <= i__2; ++j) {
if (d__[j] < p) {
k = j;
p = d__[j];
}
/* L30: */
}
if (k != i__) {
d__[k] = d__[i__];
d__[i__] = p;
sswap_(n, &z___ref(1, i__), &c__1, &z___ref(1, k), &c__1);
}
/* L40: */
}
}
}
work[1] = (real) lwmin;
iwork[1] = liwmin;
return 0;
/* End of SSTEDC */
} /* sstedc_ */
