cbdsqr.c

#include<math.h>
#include<stdlib.h>
#include<string.h>
#include<stdio.h>
#include<complex.h>
#ifdefcomplex
#undef complex
#endif
#ifdefI
#undef I
#endif

#if defined(_WIN64)
typedeflong longBLASLONG;
typedefunsigned long longBLASULONG;
#else
typedeflongBLASLONG;
typedefunsigned longBLASULONG;
#endif

#ifdefLAPACK_ILP64
typedefBLASLONGblasint;
#if defined(_WIN64)
#defineblasabs(x) llabs(x)
#else
#defineblasabs(x) labs(x)
#endif
#else
typedefintblasint;
#defineblasabs(x) abs(x)
#endif

typedefblasintinteger;

typedefunsigned intuinteger;
typedefchar*address;
typedefshort intshortint;
typedeffloatreal;
typedefdoubledoublereal;
typedefstruct { realr, i; } complex;
typedefstruct { doublerealr, i; } doublecomplex;
#ifdef_MSC_VER
staticinline_FcomplexCf(complex*z) {_Fcomplexzz={z->r , z->i}; returnzz;}
staticinline_DcomplexCd(doublecomplex*z) {_Dcomplexzz={z->r , z->i};returnzz;}
staticinline_Fcomplex*_pCf(complex*z) {return (_Fcomplex*)z;}
staticinline_Dcomplex*_pCd(doublecomplex*z) {return (_Dcomplex*)z;}
#else
staticinline_ComplexfloatCf(complex*z) {returnz->r+z->i*_Complex_I;}
staticinline_ComplexdoubleCd(doublecomplex*z) {returnz->r+z->i*_Complex_I;}
staticinline_Complexfloat*_pCf(complex*z) {return (_Complexfloat*)z;}
staticinline_Complexdouble*_pCd(doublecomplex*z) {return (_Complexdouble*)z;}
#endif
#definepCf(z) (*_pCf(z))
#definepCd(z) (*_pCd(z))
typedefintlogical;
typedefshort intshortlogical;
typedefcharlogical1;
typedefcharinteger1;

#defineTRUE_ (1)
#defineFALSE_ (0)

/* Extern is for use with -E */
#ifndefExtern
#defineExtern extern
#endif

/* I/O stuff */

typedefintflag;
typedefintftnlen;
typedefintftnint;

/*external read, write*/
typedefstruct
{ flagcierr;
ftnintciunit;
flagciend;
char*cifmt;
ftnintcirec;
} cilist;

/*internal read, write*/
typedefstruct
{ flagicierr;
char*iciunit;
flagiciend;
char*icifmt;
ftninticirlen;
ftninticirnum;
} icilist;

/*open*/
typedefstruct
{ flagoerr;
ftnintounit;
char*ofnm;
ftnlenofnmlen;
char*osta;
char*oacc;
char*ofm;
ftnintorl;
char*oblnk;
} olist;

/*close*/
typedefstruct
{ flagcerr;
ftnintcunit;
char*csta;
} cllist;

/*rewind, backspace, endfile*/
typedefstruct
{ flagaerr;
ftnintaunit;
} alist;

/* inquire */
typedefstruct
{ flaginerr;
ftnintinunit;
char*infile;
ftnleninfilen;
ftnint*inex; /*parameters in standard's order*/
ftnint*inopen;
ftnint*innum;
ftnint*innamed;
char*inname;
ftnleninnamlen;
char*inacc;
ftnleninacclen;
char*inseq;
ftnleninseqlen;
char*indir;
ftnlenindirlen;
char*infmt;
ftnleninfmtlen;
char*inform;
ftnintinformlen;
char*inunf;
ftnleninunflen;
ftnint*inrecl;
ftnint*innrec;
char*inblank;
ftnleninblanklen;
} inlist;

#defineVOID void

unionMultitype { /* for multiple entry points */
integer1g;
shortinth;
integeri;
/* longint j; */
realr;
doublereald;
complexc;
doublecomplexz;
 };

typedefunionMultitypeMultitype;

structVardesc { /* for Namelist */
char*name;
char*addr;
ftnlen*dims;
inttype;
 };
typedefstructVardescVardesc;

structNamelist {
char*name;
Vardesc**vars;
intnvars;
 };
typedefstructNamelistNamelist;

#defineabs(x) ((x) >= 0 ? (x) : -(x))
#definedabs(x) (fabs(x))
#definef2cmin(a,b) ((a) <= (b) ? (a) : (b))
#definef2cmax(a,b) ((a) >= (b) ? (a) : (b))
#definedmin(a,b) (f2cmin(a,b))
#definedmax(a,b) (f2cmax(a,b))
#definebit_test(a,b) ((a) >> (b) & 1)
#definebit_clear(a,b) ((a) & ~((uinteger)1 << (b)))
#definebit_set(a,b) ((a) | ((uinteger)1 << (b)))

#defineabort_() { sig_die("Fortran abort routine called", 1); }
#definec_abs(z) (cabsf(Cf(z)))
#definec_cos(R,Z) { pCf(R)=ccos(Cf(Z)); }
#ifdef_MSC_VER
#definec_div(c, a, b) {Cf(c)._Val[0] = (Cf(a)._Val[0]/Cf(b)._Val[0]); Cf(c)._Val[1]=(Cf(a)._Val[1]/Cf(b)._Val[1]);}
#definez_div(c, a, b) {Cd(c)._Val[0] = (Cd(a)._Val[0]/Cd(b)._Val[0]); Cd(c)._Val[1]=(Cd(a)._Val[1]/df(b)._Val[1]);}
#else
#definec_div(c, a, b) {pCf(c) = Cf(a)/Cf(b);}
#definez_div(c, a, b) {pCd(c) = Cd(a)/Cd(b);}
#endif
#definec_exp(R, Z) {pCf(R) = cexpf(Cf(Z));}
#definec_log(R, Z) {pCf(R) = clogf(Cf(Z));}
#definec_sin(R, Z) {pCf(R) = csinf(Cf(Z));}
//#define c_sqrt(R, Z) {*(R) = csqrtf(Cf(Z));}
#definec_sqrt(R, Z) {pCf(R) = csqrtf(Cf(Z));}
#defined_abs(x) (fabs(*(x)))
#defined_acos(x) (acos(*(x)))
#defined_asin(x) (asin(*(x)))
#defined_atan(x) (atan(*(x)))
#defined_atn2(x, y) (atan2(*(x),*(y)))
#defined_cnjg(R, Z) { pCd(R) = conj(Cd(Z)); }
#definer_cnjg(R, Z) { pCf(R) = conjf(Cf(Z)); }
#defined_cos(x) (cos(*(x)))
#defined_cosh(x) (cosh(*(x)))
#defined_dim(__a, __b) ( *(__a) > *(__b) ? *(__a) - *(__b) : 0.0 )
#defined_exp(x) (exp(*(x)))
#defined_imag(z) (cimag(Cd(z)))
#definer_imag(z) (cimagf(Cf(z)))
#defined_int(__x) (*(__x)>0 ? floor(*(__x)) : -floor(- *(__x)))
#definer_int(__x) (*(__x)>0 ? floor(*(__x)) : -floor(- *(__x)))
#defined_lg10(x) ( 0.43429448190325182765 * log(*(x)) )
#definer_lg10(x) ( 0.43429448190325182765 * log(*(x)) )
#defined_log(x) (log(*(x)))
#defined_mod(x, y) (fmod(*(x), *(y)))
#defineu_nint(__x) ((__x)>=0 ? floor((__x) + .5) : -floor(.5 - (__x)))
#defined_nint(x) u_nint(*(x))
#defineu_sign(__a,__b) ((__b) >= 0 ? ((__a) >= 0 ? (__a) : -(__a)) : -((__a) >= 0 ? (__a) : -(__a)))
#defined_sign(a,b) u_sign(*(a),*(b))
#definer_sign(a,b) u_sign(*(a),*(b))
#defined_sin(x) (sin(*(x)))
#defined_sinh(x) (sinh(*(x)))
#defined_sqrt(x) (sqrt(*(x)))
#defined_tan(x) (tan(*(x)))
#defined_tanh(x) (tanh(*(x)))
#definei_abs(x) abs(*(x))
#definei_dnnt(x) ((integer)u_nint(*(x)))
#definei_len(s, n) (n)
#definei_nint(x) ((integer)u_nint(*(x)))
#definei_sign(a,b) ((integer)u_sign((integer)*(a),(integer)*(b)))
#definepow_dd(ap, bp) ( pow(*(ap), *(bp)))
#definepow_si(B,E) spow_ui(*(B),*(E))
#definepow_ri(B,E) spow_ui(*(B),*(E))
#definepow_di(B,E) dpow_ui(*(B),*(E))
#definepow_zi(p, a, b) {pCd(p) = zpow_ui(Cd(a), *(b));}
#definepow_ci(p, a, b) {pCf(p) = cpow_ui(Cf(a), *(b));}
#definepow_zz(R,A,B) {pCd(R) = cpow(Cd(A),*(B));}
#defines_cat(lpp, rpp, rnp, np, llp) { ftnlen i, nc, ll; char *f__rp, *lp; ll = (llp); lp = (lpp); for(i=0; i < (int)*(np); ++i) { nc = ll; if((rnp)[i] < nc) nc = (rnp)[i]; ll -= nc; f__rp = (rpp)[i]; while(--nc >= 0) *lp++ = *(f__rp)++; } while(--ll >= 0) *lp++ = ' '; }
#defines_cmp(a,b,c,d) ((integer)strncmp((a),(b),f2cmin((c),(d))))
#defines_copy(A,B,C,D) { int __i,__m; for (__i=0, __m=f2cmin((C),(D)); __i<__m && (B)[__i] != 0; ++__i) (A)[__i] = (B)[__i]; }
#definesig_die(s, kill) { exit(1); }
#defines_stop(s, n) {exit(0);}
staticcharjunk[] ="\n@(#)LIBF77 VERSION 19990503\n";
#definez_abs(z) (cabs(Cd(z)))
#definez_exp(R, Z) {pCd(R) = cexp(Cd(Z));}
#definez_sqrt(R, Z) {pCd(R) = csqrt(Cd(Z));}
#definemyexit_() break;
#definemycycle() continue;
#definemyceiling(w) {ceil(w)}
#definemyhuge(w) {HUGE_VAL}
//#define mymaxloc_(w,s,e,n) {if (sizeof(*(w)) == sizeof(double)) dmaxloc_((w),*(s),*(e),n); else dmaxloc_((w),*(s),*(e),n);}
#definemymaxloc(w,s,e,n) {dmaxloc_(w,*(s),*(e),n)}

/* procedure parameter types for -A and -C++ */

#defineF2C_proc_par_types 1
#ifdef__cplusplus
typedeflogical (*L_fp)(...);
#else
typedeflogical (*L_fp)();
#endif

staticfloatspow_ui(floatx, integern) {
floatpow=1.0; unsigned long intu;
if(n!=0) {
if(n<0) n=-n, x=1/x;
for(u=n; ; ) {
if(u&01) pow *= x;
if(u >>= 1) x *= x;
elsebreak;
 }
 }
returnpow;
}
staticdoubledpow_ui(doublex, integern) {
doublepow=1.0; unsigned long intu;
if(n!=0) {
if(n<0) n=-n, x=1/x;
for(u=n; ; ) {
if(u&01) pow *= x;
if(u >>= 1) x *= x;
elsebreak;
 }
 }
returnpow;
}
#ifdef_MSC_VER
static_Fcomplexcpow_ui(complexx, integern) {
complexpow={1.0,0.0}; unsigned long intu;
if(n!=0) {
if(n<0) n=-n, x.r=1/x.r, x.i=1/x.i;
for(u=n; ; ) {
if(u&01) pow.r *= x.r, pow.i *= x.i;
if(u >>= 1) x.r *= x.r, x.i *= x.i;
elsebreak;
 }
 }
_Fcomplexp={pow.r, pow.i};
returnp;
}
#else
static_Complexfloatcpow_ui(_Complexfloatx, integern) {
_Complexfloatpow=1.0; unsigned long intu;
if(n!=0) {
if(n<0) n=-n, x=1/x;
for(u=n; ; ) {
if(u&01) pow *= x;
if(u >>= 1) x *= x;
elsebreak;
 }
 }
returnpow;
}
#endif
#ifdef_MSC_VER
static_Dcomplexzpow_ui(_Dcomplexx, integern) {
_Dcomplexpow={1.0,0.0}; unsigned long intu;
if(n!=0) {
if(n<0) n=-n, x._Val[0] =1/x._Val[0], x._Val[1] =1/x._Val[1];
for(u=n; ; ) {
if(u&01) pow._Val[0] *= x._Val[0], pow._Val[1] *= x._Val[1];
if(u >>= 1) x._Val[0] *= x._Val[0], x._Val[1] *= x._Val[1];
elsebreak;
 }
 }
_Dcomplexp= {pow._Val[0], pow._Val[1]};
returnp;
}
#else
static_Complexdoublezpow_ui(_Complexdoublex, integern) {
_Complexdoublepow=1.0; unsigned long intu;
if(n!=0) {
if(n<0) n=-n, x=1/x;
for(u=n; ; ) {
if(u&01) pow *= x;
if(u >>= 1) x *= x;
elsebreak;
 }
 }
returnpow;
}
#endif
staticintegerpow_ii(integerx, integern) {
integerpow; unsigned long intu;
if (n <= 0) {
if (n==0||x==1) pow=1;
elseif (x!=-1) pow=x==0 ? 1/x : 0;
elsen=-n;
 }
if ((n>0) || !(n==0||x==1||x!=-1)) {
u=n;
for(pow=1; ; ) {
if(u&01) pow *= x;
if(u >>= 1) x *= x;
elsebreak;
 }
 }
returnpow;
}
staticintegerdmaxloc_(double*w, integers, integere, integer*n)
{
doublem; integeri, mi;
for(m=w[s-1], mi=s, i=s+1; i<=e; i++)
if (w[i-1]>m) mi=i ,m=w[i-1];
returnmi-s+1;
}
staticintegersmaxloc_(float*w, integers, integere, integer*n)
{
floatm; integeri, mi;
for(m=w[s-1], mi=s, i=s+1; i<=e; i++)
if (w[i-1]>m) mi=i ,m=w[i-1];
returnmi-s+1;
}
staticinlinevoidcdotc_(complex*z, integer*n_, complex*x, integer*incx_, complex*y, integer*incy_) {
integern=*n_, incx=*incx_, incy=*incy_, i;
#ifdef_MSC_VER
_Fcomplexzdotc= {0.0, 0.0};
if (incx==1&&incy==1) {
for (i=0;i<n;i++) { /* zdotc = zdotc + dconjg(x(i))* y(i) */
zdotc._Val[0] +=conjf(Cf(&x[i]))._Val[0] *Cf(&y[i])._Val[0];
zdotc._Val[1] +=conjf(Cf(&x[i]))._Val[1] *Cf(&y[i])._Val[1];
 }
 } else {
for (i=0;i<n;i++) { /* zdotc = zdotc + dconjg(x(i))* y(i) */
zdotc._Val[0] +=conjf(Cf(&x[i*incx]))._Val[0] *Cf(&y[i*incy])._Val[0];
zdotc._Val[1] +=conjf(Cf(&x[i*incx]))._Val[1] *Cf(&y[i*incy])._Val[1];
 }
 }
pCf(z) =zdotc;
}
#else
_Complexfloatzdotc=0.0;
if (incx==1&&incy==1) {
for (i=0;i<n;i++) { /* zdotc = zdotc + dconjg(x(i))* y(i) */
zdotc+=conjf(Cf(&x[i])) *Cf(&y[i]);
 }
 } else {
for (i=0;i<n;i++) { /* zdotc = zdotc + dconjg(x(i))* y(i) */
zdotc+=conjf(Cf(&x[i*incx])) *Cf(&y[i*incy]);
 }
 }
pCf(z) =zdotc;
}
#endif
staticinlinevoidzdotc_(doublecomplex*z, integer*n_, doublecomplex*x, integer*incx_, doublecomplex*y, integer*incy_) {
integern=*n_, incx=*incx_, incy=*incy_, i;
#ifdef_MSC_VER
_Dcomplexzdotc= {0.0, 0.0};
if (incx==1&&incy==1) {
for (i=0;i<n;i++) { /* zdotc = zdotc + dconjg(x(i))* y(i) */
zdotc._Val[0] +=conj(Cd(&x[i]))._Val[0] *Cd(&y[i])._Val[0];
zdotc._Val[1] +=conj(Cd(&x[i]))._Val[1] *Cd(&y[i])._Val[1];
 }
 } else {
for (i=0;i<n;i++) { /* zdotc = zdotc + dconjg(x(i))* y(i) */
zdotc._Val[0] +=conj(Cd(&x[i*incx]))._Val[0] *Cd(&y[i*incy])._Val[0];
zdotc._Val[1] +=conj(Cd(&x[i*incx]))._Val[1] *Cd(&y[i*incy])._Val[1];
 }
 }
pCd(z) =zdotc;
}
#else
_Complexdoublezdotc=0.0;
if (incx==1&&incy==1) {
for (i=0;i<n;i++) { /* zdotc = zdotc + dconjg(x(i))* y(i) */
zdotc+=conj(Cd(&x[i])) *Cd(&y[i]);
 }
 } else {
for (i=0;i<n;i++) { /* zdotc = zdotc + dconjg(x(i))* y(i) */
zdotc+=conj(Cd(&x[i*incx])) *Cd(&y[i*incy]);
 }
 }
pCd(z) =zdotc;
}
#endif
staticinlinevoidcdotu_(complex*z, integer*n_, complex*x, integer*incx_, complex*y, integer*incy_) {
integern=*n_, incx=*incx_, incy=*incy_, i;
#ifdef_MSC_VER
_Fcomplexzdotc= {0.0, 0.0};
if (incx==1&&incy==1) {
for (i=0;i<n;i++) { /* zdotc = zdotc + dconjg(x(i))* y(i) */
zdotc._Val[0] +=Cf(&x[i])._Val[0] *Cf(&y[i])._Val[0];
zdotc._Val[1] +=Cf(&x[i])._Val[1] *Cf(&y[i])._Val[1];
 }
 } else {
for (i=0;i<n;i++) { /* zdotc = zdotc + dconjg(x(i))* y(i) */
zdotc._Val[0] +=Cf(&x[i*incx])._Val[0] *Cf(&y[i*incy])._Val[0];
zdotc._Val[1] +=Cf(&x[i*incx])._Val[1] *Cf(&y[i*incy])._Val[1];
 }
 }
pCf(z) =zdotc;
}
#else
_Complexfloatzdotc=0.0;
if (incx==1&&incy==1) {
for (i=0;i<n;i++) { /* zdotc = zdotc + dconjg(x(i))* y(i) */
zdotc+=Cf(&x[i]) *Cf(&y[i]);
 }
 } else {
for (i=0;i<n;i++) { /* zdotc = zdotc + dconjg(x(i))* y(i) */
zdotc+=Cf(&x[i*incx]) *Cf(&y[i*incy]);
 }
 }
pCf(z) =zdotc;
}
#endif
staticinlinevoidzdotu_(doublecomplex*z, integer*n_, doublecomplex*x, integer*incx_, doublecomplex*y, integer*incy_) {
integern=*n_, incx=*incx_, incy=*incy_, i;
#ifdef_MSC_VER
_Dcomplexzdotc= {0.0, 0.0};
if (incx==1&&incy==1) {
for (i=0;i<n;i++) { /* zdotc = zdotc + dconjg(x(i))* y(i) */
zdotc._Val[0] +=Cd(&x[i])._Val[0] *Cd(&y[i])._Val[0];
zdotc._Val[1] +=Cd(&x[i])._Val[1] *Cd(&y[i])._Val[1];
 }
 } else {
for (i=0;i<n;i++) { /* zdotc = zdotc + dconjg(x(i))* y(i) */
zdotc._Val[0] +=Cd(&x[i*incx])._Val[0] *Cd(&y[i*incy])._Val[0];
zdotc._Val[1] +=Cd(&x[i*incx])._Val[1] *Cd(&y[i*incy])._Val[1];
 }
 }
pCd(z) =zdotc;
}
#else
_Complexdoublezdotc=0.0;
if (incx==1&&incy==1) {
for (i=0;i<n;i++) { /* zdotc = zdotc + dconjg(x(i))* y(i) */
zdotc+=Cd(&x[i]) *Cd(&y[i]);
 }
 } else {
for (i=0;i<n;i++) { /* zdotc = zdotc + dconjg(x(i))* y(i) */
zdotc+=Cd(&x[i*incx]) *Cd(&y[i*incy]);
 }
 }
pCd(z) =zdotc;
}
#endif
/* -- translated by f2c (version 20000121).
 You must link the resulting object file with the libraries:
 -lf2c -lm (in that order)
*/


/* -- translated by f2c (version 20000121).
 You must link the resulting object file with the libraries:
 -lf2c -lm (in that order)
*/



/* Table of constant values */

staticdoublerealc_b15=-.125;
staticintegerc__1=1;
staticrealc_b49=1.f;
staticrealc_b72=-1.f;

/* > \brief \b CBDSQR */

/* =========== DOCUMENTATION =========== */

/* Online html documentation available at */
/* http://www.netlib.org/lapack/explore-html/ */

/* > \htmlonly */
/* > Download CBDSQR + dependencies */
/* > <a href="http://www.netlib.org/cgi-bin/netlibfiles.tgz?format=tgz&filename=/lapack/lapack_routine/cbdsqr.
f"> */
/* > [TGZ]</a> */
/* > <a href="http://www.netlib.org/cgi-bin/netlibfiles.zip?format=zip&filename=/lapack/lapack_routine/cbdsqr.
f"> */
/* > [ZIP]</a> */
/* > <a href="http://www.netlib.org/cgi-bin/netlibfiles.txt?format=txt&filename=/lapack/lapack_routine/cbdsqr.
f"> */
/* > [TXT]</a> */
/* > \endhtmlonly */

/* Definition: */
/* =========== */

/* SUBROUTINE CBDSQR( UPLO, N, NCVT, NRU, NCC, D, E, VT, LDVT, U, */
/* LDU, C, LDC, RWORK, INFO ) */

/* CHARACTER UPLO */
/* INTEGER INFO, LDC, LDU, LDVT, N, NCC, NCVT, NRU */
/* REAL D( * ), E( * ), RWORK( * ) */
/* COMPLEX C( LDC, * ), U( LDU, * ), VT( LDVT, * ) */


/* > \par Purpose: */
/* ============= */
/* > */
/* > \verbatim */
/* > */
/* > CBDSQR computes the singular values and, optionally, the right and/or */
/* > left singular vectors from the singular value decomposition (SVD) of */
/* > a real N-by-N (upper or lower) bidiagonal matrix B using the implicit */
/* > zero-shift QR algorithm. The SVD of B has the form */
/* > */
/* > B = Q * S * P**H */
/* > */
/* > where S is the diagonal matrix of singular values, Q is an orthogonal */
/* > matrix of left singular vectors, and P is an orthogonal matrix of */
/* > right singular vectors. If left singular vectors are requested, this */
/* > subroutine actually returns U*Q instead of Q, and, if right singular */
/* > vectors are requested, this subroutine returns P**H*VT instead of */
/* > P**H, for given complex input matrices U and VT. When U and VT are */
/* > the unitary matrices that reduce a general matrix A to bidiagonal */
/* > form: A = U*B*VT, as computed by CGEBRD, then */
/* > */
/* > A = (U*Q) * S * (P**H*VT) */
/* > */
/* > is the SVD of A. Optionally, the subroutine may also compute Q**H*C */
/* > for a given complex input matrix C. */
/* > */
/* > See "Computing Small Singular Values of Bidiagonal Matrices With */
/* > Guaranteed High Relative Accuracy," by J. Demmel and W. Kahan, */
/* > LAPACK Working Note #3 (or SIAM J. Sci. Statist. Comput. vol. 11, */
/* > no. 5, pp. 873-912, Sept 1990) and */
/* > "Accurate singular values and differential qd algorithms," by */
/* > B. Parlett and V. Fernando, Technical Report CPAM-554, Mathematics */
/* > Department, University of California at Berkeley, July 1992 */
/* > for a detailed description of the algorithm. */
/* > \endverbatim */

/* Arguments: */
/* ========== */

/* > \param[in] UPLO */
/* > \verbatim */
/* > UPLO is CHARACTER*1 */
/* > = 'U': B is upper bidiagonal; */
/* > = 'L': B is lower bidiagonal. */
/* > \endverbatim */
/* > */
/* > \param[in] N */
/* > \verbatim */
/* > N is INTEGER */
/* > The order of the matrix B. N >= 0. */
/* > \endverbatim */
/* > */
/* > \param[in] NCVT */
/* > \verbatim */
/* > NCVT is INTEGER */
/* > The number of columns of the matrix VT. NCVT >= 0. */
/* > \endverbatim */
/* > */
/* > \param[in] NRU */
/* > \verbatim */
/* > NRU is INTEGER */
/* > The number of rows of the matrix U. NRU >= 0. */
/* > \endverbatim */
/* > */
/* > \param[in] NCC */
/* > \verbatim */
/* > NCC is INTEGER */
/* > The number of columns of the matrix C. NCC >= 0. */
/* > \endverbatim */
/* > */
/* > \param[in,out] D */
/* > \verbatim */
/* > D is REAL array, dimension (N) */
/* > On entry, the n diagonal elements of the bidiagonal matrix B. */
/* > On exit, if INFO=0, the singular values of B in decreasing */
/* > order. */
/* > \endverbatim */
/* > */
/* > \param[in,out] E */
/* > \verbatim */
/* > E is REAL array, dimension (N-1) */
/* > On entry, the N-1 offdiagonal elements of the bidiagonal */
/* > matrix B. */
/* > On exit, if INFO = 0, E is destroyed; if INFO > 0, D and E */
/* > will contain the diagonal and superdiagonal elements of a */
/* > bidiagonal matrix orthogonally equivalent to the one given */
/* > as input. */
/* > \endverbatim */
/* > */
/* > \param[in,out] VT */
/* > \verbatim */
/* > VT is COMPLEX array, dimension (LDVT, NCVT) */
/* > On entry, an N-by-NCVT matrix VT. */
/* > On exit, VT is overwritten by P**H * VT. */
/* > Not referenced if NCVT = 0. */
/* > \endverbatim */
/* > */
/* > \param[in] LDVT */
/* > \verbatim */
/* > LDVT is INTEGER */
/* > The leading dimension of the array VT. */
/* > LDVT >= f2cmax(1,N) if NCVT > 0; LDVT >= 1 if NCVT = 0. */
/* > \endverbatim */
/* > */
/* > \param[in,out] U */
/* > \verbatim */
/* > U is COMPLEX array, dimension (LDU, N) */
/* > On entry, an NRU-by-N matrix U. */
/* > On exit, U is overwritten by U * Q. */
/* > Not referenced if NRU = 0. */
/* > \endverbatim */
/* > */
/* > \param[in] LDU */
/* > \verbatim */
/* > LDU is INTEGER */
/* > The leading dimension of the array U. LDU >= f2cmax(1,NRU). */
/* > \endverbatim */
/* > */
/* > \param[in,out] C */
/* > \verbatim */
/* > C is COMPLEX array, dimension (LDC, NCC) */
/* > On entry, an N-by-NCC matrix C. */
/* > On exit, C is overwritten by Q**H * C. */
/* > Not referenced if NCC = 0. */
/* > \endverbatim */
/* > */
/* > \param[in] LDC */
/* > \verbatim */
/* > LDC is INTEGER */
/* > The leading dimension of the array C. */
/* > LDC >= f2cmax(1,N) if NCC > 0; LDC >=1 if NCC = 0. */
/* > \endverbatim */
/* > */
/* > \param[out] RWORK */
/* > \verbatim */
/* > RWORK is REAL array, dimension (4*N) */
/* > \endverbatim */
/* > */
/* > \param[out] INFO */
/* > \verbatim */
/* > INFO is INTEGER */
/* > = 0: successful exit */
/* > < 0: If INFO = -i, the i-th argument had an illegal value */
/* > > 0: the algorithm did not converge; D and E contain the */
/* > elements of a bidiagonal matrix which is orthogonally */
/* > similar to the input matrix B; if INFO = i, i */
/* > elements of E have not converged to zero. */
/* > \endverbatim */

/* > \par Internal Parameters: */
/* ========================= */
/* > */
/* > \verbatim */
/* > TOLMUL REAL, default = f2cmax(10,f2cmin(100,EPS**(-1/8))) */
/* > TOLMUL controls the convergence criterion of the QR loop. */
/* > If it is positive, TOLMUL*EPS is the desired relative */
/* > precision in the computed singular values. */
/* > If it is negative, abs(TOLMUL*EPS*sigma_max) is the */
/* > desired absolute accuracy in the computed singular */
/* > values (corresponds to relative accuracy */
/* > abs(TOLMUL*EPS) in the largest singular value. */
/* > abs(TOLMUL) should be between 1 and 1/EPS, and preferably */
/* > between 10 (for fast convergence) and .1/EPS */
/* > (for there to be some accuracy in the results). */
/* > Default is to lose at either one eighth or 2 of the */
/* > available decimal digits in each computed singular value */
/* > (whichever is smaller). */
/* > */
/* > MAXITR INTEGER, default = 6 */
/* > MAXITR controls the maximum number of passes of the */
/* > algorithm through its inner loop. The algorithms stops */
/* > (and so fails to converge) if the number of passes */
/* > through the inner loop exceeds MAXITR*N**2. */
/* > \endverbatim */

/* Authors: */
/* ======== */

/* > \author Univ. of Tennessee */
/* > \author Univ. of California Berkeley */
/* > \author Univ. of Colorado Denver */
/* > \author NAG Ltd. */

/* > \date December 2016 */

/* > \ingroup complexOTHERcomputational */

/* ===================================================================== */
/* Subroutine */intcbdsqr_(char*uplo, integer*n, integer*ncvt, integer*
nru, integer*ncc, real*d__, real*e, complex*vt, integer*ldvt, 
complex*u, integer*ldu, complex*c__, integer*ldc, real*rwork, 
integer*info)
{
/* System generated locals */
integerc_dim1, c_offset, u_dim1, u_offset, vt_dim1, vt_offset, i__1, 
i__2;
realr__1, r__2, r__3, r__4;
doublereald__1;

/* Local variables */
realabse;
integeridir;
realabss;
integeroldm;
realcosl;
integerisub, iter;
realunfl, sinl, cosr, smin, smax, sinr;
extern/* Subroutine */intslas2_(real*, real*, real*, real*, real*)
 ;
realf, g, h__;
integeri__, j, m;
realr__;
externlogicallsame_(char*, char*);
realoldcs;
extern/* Subroutine */intclasr_(char*, char*, char*, integer*, 
integer*, real*, real*, complex*, integer*);
integeroldll;
realshift, sigmn, oldsn;
extern/* Subroutine */intcswap_(integer*, complex*, integer*, 
complex*, integer*);
integermaxit;
realsminl, sigmx;
logicallower;
extern/* Subroutine */intcsrot_(integer*, complex*, integer*, 
complex*, integer*, real*, real*), slasq1_(integer*, real*, 
real*, real*, integer*), slasv2_(real*, real*, real*, real*
 , real*, real*, real*, real*, real*);
realcs;
integerll;
realsn, mu;
externrealslamch_(char*);
extern/* Subroutine */intcsscal_(integer*, real*, complex*, integer
*), xerbla_(char*, integer*, ftnlen);
realsminoa;
extern/* Subroutine */intslartg_(real*, real*, real*, real*, real*
 );
realthresh;
logicalrotate;
integernm1;
realtolmul;
integernm12, nm13, lll;
realeps, sll, tol;


/* -- LAPACK computational routine (version 3.7.0) -- */
/* -- LAPACK is a software package provided by Univ. of Tennessee, -- */
/* -- Univ. of California Berkeley, Univ. of Colorado Denver and NAG Ltd..-- */
/* December 2016 */


/* ===================================================================== */


/* Test the input parameters. */

/* Parameter adjustments */
--d__;
--e;
vt_dim1=*ldvt;
vt_offset=1+vt_dim1*1;
vt-=vt_offset;
u_dim1=*ldu;
u_offset=1+u_dim1*1;
u-=u_offset;
c_dim1=*ldc;
c_offset=1+c_dim1*1;
c__-=c_offset;
--rwork;

/* Function Body */
*info=0;
lower=lsame_(uplo, "L");
if (! lsame_(uplo, "U") && ! lower) {
*info=-1;
 } elseif (*n<0) {
*info=-2;
 } elseif (*ncvt<0) {
*info=-3;
 } elseif (*nru<0) {
*info=-4;
 } elseif (*ncc<0) {
*info=-5;
 } elseif (*ncvt==0&&*ldvt<1||*ncvt>0&&*ldvt<f2cmax(1,*n)) {
*info=-9;
 } elseif (*ldu<f2cmax(1,*nru)) {
*info=-11;
 } elseif (*ncc==0&&*ldc<1||*ncc>0&&*ldc<f2cmax(1,*n)) {
*info=-13;
 }
if (*info!=0) {
i__1=-(*info);
xerbla_("CBDSQR", &i__1, (ftnlen)6);
return0;
 }
if (*n==0) {
return0;
 }
if (*n==1) {
 goto L160;
 }

/* ROTATE is true if any singular vectors desired, false otherwise */

rotate=*ncvt>0||*nru>0||*ncc>0;

/* If no singular vectors desired, use qd algorithm */

if (! rotate) {
slasq1_(n, &d__[1], &e[1], &rwork[1], info);

/* If INFO equals 2, dqds didn't finish, try to finish */

if (*info!=2) {
return0;
 }
*info=0;
 }

nm1=*n-1;
nm12=nm1+nm1;
nm13=nm12+nm1;
idir=0;

/* Get machine constants */

eps=slamch_("Epsilon");
unfl=slamch_("Safe minimum");

/* If matrix lower bidiagonal, rotate to be upper bidiagonal */
/* by applying Givens rotations on the left */

if (lower) {
i__1=*n-1;
for (i__=1; i__ <= i__1; ++i__) {
slartg_(&d__[i__], &e[i__], &cs, &sn, &r__);
d__[i__] =r__;
e[i__] =sn*d__[i__+1];
d__[i__+1] =cs*d__[i__+1];
rwork[i__] =cs;
rwork[nm1+i__] =sn;
/* L10: */
 }

/* Update singular vectors if desired */

if (*nru>0) {
clasr_("R", "V", "F", nru, n, &rwork[1], &rwork[*n], &u[u_offset],
ldu);
 }
if (*ncc>0) {
clasr_("L", "V", "F", n, ncc, &rwork[1], &rwork[*n], &c__[
c_offset], ldc);
 }
 }

/* Compute singular values to relative accuracy TOL */
/* (By setting TOL to be negative, algorithm will compute */
/* singular values to absolute accuracy ABS(TOL)*norm(input matrix)) */

/* Computing MAX */
/* Computing MIN */
d__1= (doublereal) eps;
r__3=100.f, r__4=pow_dd(&d__1, &c_b15);
r__1=10.f, r__2=f2cmin(r__3,r__4);
tolmul=f2cmax(r__1,r__2);
tol=tolmul*eps;

/* Compute approximate maximum, minimum singular values */

smax=0.f;
i__1=*n;
for (i__=1; i__ <= i__1; ++i__) {
/* Computing MAX */
r__2=smax, r__3= (r__1=d__[i__], abs(r__1));
smax=f2cmax(r__2,r__3);
/* L20: */
 }
i__1=*n-1;
for (i__=1; i__ <= i__1; ++i__) {
/* Computing MAX */
r__2=smax, r__3= (r__1=e[i__], abs(r__1));
smax=f2cmax(r__2,r__3);
/* L30: */
 }
sminl=0.f;
if (tol >= 0.f) {

/* Relative accuracy desired */

sminoa=abs(d__[1]);
if (sminoa==0.f) {
 goto L50;
 }
mu=sminoa;
i__1=*n;
for (i__=2; i__ <= i__1; ++i__) {
mu= (r__2=d__[i__], abs(r__2)) * (mu / (mu+ (r__1=e[i__-1]
 , abs(r__1))));
sminoa=f2cmin(sminoa,mu);
if (sminoa==0.f) {
 goto L50;
 }
/* L40: */
 }
L50:
sminoa /= sqrt((real) (*n));
/* Computing MAX */
r__1=tol*sminoa, r__2=*n*6**n*unfl;
thresh=f2cmax(r__1,r__2);
 } else {

/* Absolute accuracy desired */

/* Computing MAX */
r__1=abs(tol) *smax, r__2=*n*6**n*unfl;
thresh=f2cmax(r__1,r__2);
 }

/* Prepare for main iteration loop for the singular values */
/* (MAXIT is the maximum number of passes through the inner */
/* loop permitted before nonconvergence signalled.) */

maxit=*n*6**n;
iter=0;
oldll=-1;
oldm=-1;

/* M points to last element of unconverged part of matrix */

m=*n;

/* Begin main iteration loop */

L60:

/* Check for convergence or exceeding iteration count */

if (m <= 1) {
 goto L160;
 }
if (iter>maxit) {
 goto L200;
 }