.TH "SRC/zbdsqr.f" 3 "Version 3.12.0" "LAPACK" \" -*- nroff -*-
.ad l
.nh
.SH NAME
SRC/zbdsqr.f
.SH SYNOPSIS
.br
.PP
.SS "Functions/Subroutines"

.in +1c
.ti -1c
.RI "subroutine \fBzbdsqr\fP (uplo, n, ncvt, nru, ncc, d, e, vt, ldvt, u, ldu, c, ldc, rwork, info)"
.br
.RI "\fBZBDSQR\fP "
.in -1c
.SH "Function/Subroutine Documentation"
.PP 
.SS "subroutine zbdsqr (character uplo, integer n, integer ncvt, integer nru, integer ncc, double precision, dimension( * ) d, double precision, dimension( * ) e, complex*16, dimension( ldvt, * ) vt, integer ldvt, complex*16, dimension( ldu, * ) u, integer ldu, complex*16, dimension( ldc, * ) c, integer ldc, double precision, dimension( * ) rwork, integer info)"

.PP
\fBZBDSQR\fP  
.PP
\fBPurpose:\fP
.RS 4

.PP
.nf
!>
!> ZBDSQR 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 ZGEBRD, 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  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
!>  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\&.
!> 
.fi
.PP
 
.RE
.PP
\fBParameters\fP
.RS 4
\fIUPLO\fP 
.PP
.nf
!>          UPLO is CHARACTER*1
!>          = 'U':  B is upper bidiagonal;
!>          = 'L':  B is lower bidiagonal\&.
!> 
.fi
.PP
.br
\fIN\fP 
.PP
.nf
!>          N is INTEGER
!>          The order of the matrix B\&.  N >= 0\&.
!> 
.fi
.PP
.br
\fINCVT\fP 
.PP
.nf
!>          NCVT is INTEGER
!>          The number of columns of the matrix VT\&. NCVT >= 0\&.
!> 
.fi
.PP
.br
\fINRU\fP 
.PP
.nf
!>          NRU is INTEGER
!>          The number of rows of the matrix U\&. NRU >= 0\&.
!> 
.fi
.PP
.br
\fINCC\fP 
.PP
.nf
!>          NCC is INTEGER
!>          The number of columns of the matrix C\&. NCC >= 0\&.
!> 
.fi
.PP
.br
\fID\fP 
.PP
.nf
!>          D is DOUBLE PRECISION 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\&.
!> 
.fi
.PP
.br
\fIE\fP 
.PP
.nf
!>          E is DOUBLE PRECISION 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\&.
!> 
.fi
.PP
.br
\fIVT\fP 
.PP
.nf
!>          VT is COMPLEX*16 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\&.
!> 
.fi
.PP
.br
\fILDVT\fP 
.PP
.nf
!>          LDVT is INTEGER
!>          The leading dimension of the array VT\&.
!>          LDVT >= max(1,N) if NCVT > 0; LDVT >= 1 if NCVT = 0\&.
!> 
.fi
.PP
.br
\fIU\fP 
.PP
.nf
!>          U is COMPLEX*16 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\&.
!> 
.fi
.PP
.br
\fILDU\fP 
.PP
.nf
!>          LDU is INTEGER
!>          The leading dimension of the array U\&.  LDU >= max(1,NRU)\&.
!> 
.fi
.PP
.br
\fIC\fP 
.PP
.nf
!>          C is COMPLEX*16 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\&.
!> 
.fi
.PP
.br
\fILDC\fP 
.PP
.nf
!>          LDC is INTEGER
!>          The leading dimension of the array C\&.
!>          LDC >= max(1,N) if NCC > 0; LDC >=1 if NCC = 0\&.
!> 
.fi
.PP
.br
\fIRWORK\fP 
.PP
.nf
!>          RWORK is DOUBLE PRECISION array, dimension (LRWORK)
!>          LRWORK = 4*N, if NCVT = NRU = NCC = 0, and
!>          LRWORK = 4*(N-1), otherwise
!> 
.fi
.PP
.br
\fIINFO\fP 
.PP
.nf
!>          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\&.
!> 
.fi
.PP
 
.RE
.PP
\fBInternal Parameters:\fP
.RS 4

.PP
.nf
!>  TOLMUL  DOUBLE PRECISION, default = max(10,min(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\&.
!>
!> 
.fi
.PP
 
.RE
.PP
\fBNote:\fP
.RS 4

.PP
.nf
!>  Bug report from Cezary Dendek\&.
!>  On November 3rd 2023, the INTEGER variable MAXIT = MAXITR*N**2 is
!>  removed since it can overflow pretty easily (for N larger or equal
!>  than 18,919)\&. We instead use MAXITDIVN = MAXITR*N\&.
!> 
.fi
.PP
 
.RE
.PP
\fBAuthor\fP
.RS 4
Univ\&. of Tennessee 

.PP
Univ\&. of California Berkeley 

.PP
Univ\&. of Colorado Denver 

.PP
NAG Ltd\&. 
.RE
.PP

.PP
Definition at line \fB233\fP of file \fBzbdsqr\&.f\fP\&.
.SH "Author"
.PP 
Generated automatically by Doxygen for LAPACK from the source code\&.