Loading...
Searching...
No Matches

## sbdsqr()

subroutine sbdsqr | ( | character | uplo,
|  | integer | n,
|  | integer | ncvt,
|  | integer | nru,
|  | integer | ncc,
|  | real, dimension( * ) | d,
|  | real, dimension( * ) | e,
|  | real, dimension( ldvt, * ) | vt,
|  | integer | ldvt,
|  | real, dimension( ldu, * ) | u,
|  | integer | ldu,
|  | real, dimension( ldc, * ) | c,
|  | integer | ldc,
|  | real, dimension( * ) | work,
|  | integer | info )

SBDSQR

Download SBDSQR + dependencies [TGZ] [ZIP] [TXT]

Purpose:

      !>
      !> SBDSQR 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**T
      !>
      !> 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**T*VT instead of
      !> P**T, for given real input matrices U and VT.  When U and VT are the
      !> orthogonal matrices that reduce a general matrix A to bidiagonal
      !> form:  A = U*B*VT, as computed by SGEBRD, then
      !>
      !>    A = (U*Q) * S * (P**T*VT)
      !>
      !> is the SVD of A.  Optionally, the subroutine may also compute Q**T*C
      !> for a given real 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.
      !>

Parameters

  [in]

  UPLO

      !>          UPLO is CHARACTER*1
      !>          = 'U':  B is upper bidiagonal;
      !>          = 'L':  B is lower bidiagonal.
      !>

  [in]

  N

      !>          N is INTEGER
      !>          The order of the matrix B.  N >= 0.
      !>

  [in]

  NCVT

      !>          NCVT is INTEGER
      !>          The number of columns of the matrix VT. NCVT >= 0.
      !>

  [in]

  NRU

      !>          NRU is INTEGER
      !>          The number of rows of the matrix U. NRU >= 0.
      !>

  [in]

  NCC

      !>          NCC is INTEGER
      !>          The number of columns of the matrix C. NCC >= 0.
      !>

  [in,out]

  D

      !>          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.
      !>

  [in,out]

  E

      !>          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.
      !>

  [in,out]

  VT

      !>          VT is REAL array, dimension (LDVT, NCVT)
      !>          On entry, an N-by-NCVT matrix VT.
      !>          On exit, VT is overwritten by P**T * VT.
      !>          Not referenced if NCVT = 0.
      !>

  [in]

  LDVT

      !>          LDVT is INTEGER
      !>          The leading dimension of the array VT.
      !>          LDVT >= max(1,N) if NCVT > 0; LDVT >= 1 if NCVT = 0.
      !>

  [in,out]

  U

      !>          U is REAL 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.
      !>

  [in]

  LDU

      !>          LDU is INTEGER
      !>          The leading dimension of the array U.  LDU >= max(1,NRU).
      !>

  [in,out]

  C

      !>          C is REAL array, dimension (LDC, NCC)
      !>          On entry, an N-by-NCC matrix C.
      !>          On exit, C is overwritten by Q**T * C.
      !>          Not referenced if NCC = 0.
      !>

  [in]

  LDC

      !>          LDC is INTEGER
      !>          The leading dimension of the array C.
      !>          LDC >= max(1,N) if NCC > 0; LDC >=1 if NCC = 0.
      !>

  [out]

  WORK

      !>          WORK is REAL array, dimension (LWORK)
      !>          LWORK = 4*N, if NCVT = NRU = NCC = 0, and
      !>          LWORK = 4*(N-1), otherwise
      !>

  [out]

  INFO

      !>          INFO is INTEGER
      !>          = 0:  successful exit
      !>          < 0:  If INFO = -i, the i-th argument had an illegal value
      !>          > 0:
      !>             if NCVT = NRU = NCC = 0,
      !>                = 1, a split was marked by a positive value in E
      !>                = 2, current block of Z not diagonalized after 30*N
      !>                     iterations (in inner while loop)
      !>                = 3, termination criterion of outer while loop not met
      !>                     (program created more than N unreduced blocks)
      !>             else NCVT = NRU = NCC = 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.
      !>

Internal Parameters:

      !>  TOLMUL  REAL, 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.
      !>

Note:

      !>  Bug report from Cezary Dendek.
      !>  On March 23rd 2017, 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.
      !>

Author
  Univ. of Tennessee
  Univ. of California Berkeley
  Univ. of Colorado Denver
  NAG Ltd.