Contents


NAME

     sbdsqr - compute the singular value decomposition (SVD) of a
     real N-by-N (upper or lower) bidiagonal matrix B.

SYNOPSIS

     SUBROUTINE SBDSQR(UPLO, N, NCVT, NRU, NCC, D, E, VT, LDVT, U, LDU, C,
           LDC, WORK, INFO)

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

     SUBROUTINE SBDSQR_64(UPLO, N, NCVT, NRU, NCC, D, E, VT, LDVT, U, LDU,
           C, LDC, WORK, INFO)

     CHARACTER * 1 UPLO
     INTEGER*8 N, NCVT, NRU, NCC, LDVT, LDU, LDC, INFO
     REAL D(*), E(*), VT(LDVT,*), U(LDU,*), C(LDC,*), WORK(*)

  F95 INTERFACE
     SUBROUTINE BDSQR(UPLO, [N], [NCVT], [NRU], [NCC], D, E, VT, [LDVT],
            U, [LDU], C, [LDC], [WORK], [INFO])

     CHARACTER(LEN=1) :: UPLO
     INTEGER :: N, NCVT, NRU, NCC, LDVT, LDU, LDC, INFO
     REAL, DIMENSION(:) :: D, E, WORK
     REAL, DIMENSION(:,:) :: VT, U, C

     SUBROUTINE BDSQR_64(UPLO, [N], [NCVT], [NRU], [NCC], D, E, VT, [LDVT],
            U, [LDU], C, [LDC], [WORK], [INFO])

     CHARACTER(LEN=1) :: UPLO
     INTEGER(8) :: N, NCVT, NRU, NCC, LDVT, LDU, LDC, INFO
     REAL, DIMENSION(:) :: D, E, WORK
     REAL, DIMENSION(:,:) :: VT, U, C

  C INTERFACE
     #include <sunperf.h>

     void sbdsqr(char uplo, int n, int ncvt, int  nru,  int  ncc,
               float *d, float *e, float *vt, int ldvt, float *u,
               int ldu, float *c, int ldc, int *info);

     void sbdsqr_64(char uplo, long n, long ncvt, long nru,  long
               ncc,  float  *d,  float  *e, float *vt, long ldvt,
               float *u, long  ldu,  float  *c,  long  ldc,  long
               *info);

PURPOSE

     sbdsqr computes the singular value decomposition (SVD) of  a
     real N-by-N (upper or lower) bidiagonal matrix B:  B = Q * S
     * P' (P' denotes the transpose of P), where S is a  diagonal
     matrix  with  non-negative  diagonal  elements (the singular
     values of B), and Q and P are orthogonal matrices.

     The routine computes S, and optionally computes U * Q, P'  *
     VT, or Q' * C, for given real input matrices U, VT, and 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. Com-
     put. 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  Berke-
     ley, July 1992 for a detailed description of the algorithm.

ARGUMENTS

     UPLO (input)
               = 'U':  B is upper bidiagonal;
               = 'L':  B is lower bidiagonal.

     N (input) The order of the matrix B.  N >= 0.

     NCVT (input)
               The number of columns of the matrix VT. NCVT >= 0.

     NRU (input)
               The number of rows of the matrix U. NRU >= 0.

     NCC (input)
               The number of columns of the matrix C. NCC >= 0.

     D (input/output)
               On entry, the n diagonal elements of the  bidiago-
               nal  matrix  B.   On exit, if INFO=0, the singular
               values of B in decreasing order.

     E (input/output)
               On entry, the elements of E contain the  offdiago-
               nal elements of the bidiagonal matrix whose SVD is
               desired.  On  normal  exit  (INFO  =  0),   E   is
               destroyed.   If  the  algorithm  does not converge
               (INFO > 0), D and E will contain the diagonal  and
               superdiagonal  elements  of  a  bidiagonal  matrix
               orthogonally equivalent to the one given as input.
               E(N) is used for workspace.

     VT (input/output)
               On entry, an N-by-NCVT matrix VT.  On exit, VT  is
               overwritten  by  P' * VT.  VT is not referenced if
               NCVT = 0.

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

     U (input/output)
               On entry, an NRU-by-N matrix U.   On  exit,  U  is
               overwritten  by U * Q.  U is not referenced if NRU
               = 0.

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

     C (input/output)
               On entry, an N-by-NCC matrix C.   On  exit,  C  is
               overwritten by Q' * C.  C is not referenced if NCC
               = 0.

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

     WORK (workspace)
               dimension(4*N)

     INFO (output)
               = 0:  successful exit
               < 0:  If INFO = -i, the i-th argument had an ille-
               gal value
               > 0:  the algorithm did not converge; D and E con-
               tain  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.