lasdq(3)

NAME
lasdq - lasdq: D&C step: leaf using bdsqr

SYNOPSIS

  Functions

subroutine dlasdq (uplo, sqre, n, ncvt, nru, ncc, d, e, vt, ldvt, u, ldu, c, ldc, work, info)
DLASDQ computes the SVD of a real bidiagonal matrix with diagonal d and off-diagonal e. Used by sbdsdc.
subroutine slasdq (uplo, sqre, n, ncvt, nru, ncc, d, e, vt, ldvt, u, ldu, c, ldc, work, info)
SLASDQ computes the SVD of a real bidiagonal matrix with diagonal d and off-diagonal e. Used by sbdsdc.

Detailed Description

Function Documentation

  subroutine dlasdq (character uplo, integer sqre, integer n, integer ncvt, integer nru, integer ncc, double precision, dimension( * ) d, double precision, dimension( * ) e, double precision, dimension( ldvt, * ) vt, integer ldvt, double precision, dimension( ldu, * ) u, integer ldu, double precision, dimension( ldc, * ) c, integer ldc, double precision, dimension( * ) work, integer info)

DLASDQ computes the SVD of a real bidiagonal matrix with diagonal d and off-diagonal e. Used by sbdsdc.

Purpose:

    !>
    !> DLASDQ computes the singular value decomposition (SVD) of a real
    !> (upper or lower) bidiagonal matrix with diagonal D and offdiagonal
    !> E, accumulating the transformations if desired. Letting B denote
    !> the input bidiagonal matrix, the algorithm computes orthogonal
    !> matrices Q and P such that B = Q * S * P**T (P**T denotes the transpose
    !> of P). The singular values S are overwritten on D.
    !>
    !> The input matrix U  is changed to U  * Q  if desired.
    !> The input matrix VT is changed to P**T * VT if desired.
    !> The input matrix C  is changed to Q**T * C  if desired.
    !>
    !> See  by J. Demmel and W. Kahan,
    !> LAPACK Working Note #3, for a detailed description of the algorithm.
    !>

Parameters
    UPLO

    !>          UPLO is CHARACTER*1
    !>        On entry, UPLO specifies whether the input bidiagonal matrix
    !>        is upper or lower bidiagonal, and whether it is square are
    !>        not.
    !>           UPLO = 'U' or 'u'   B is upper bidiagonal.
    !>           UPLO = 'L' or 'l'   B is lower bidiagonal.
    !>

    SQRE

    !>          SQRE is INTEGER
    !>        = 0: then the input matrix is N-by-N.
    !>        = 1: then the input matrix is N-by-(N+1) if UPLU = 'U' and
    !>             (N+1)-by-N if UPLU = 'L'.
    !>
    !>        The bidiagonal matrix has
    !>        N = NL + NR + 1 rows and
    !>        M = N + SQRE >= N columns.
    !>

    N

    !>          N is INTEGER
    !>        On entry, N specifies the number of rows and columns
    !>        in the matrix. N must be at least 0.
    !>

    NCVT

    !>          NCVT is INTEGER
    !>        On entry, NCVT specifies the number of columns of
    !>        the matrix VT. NCVT must be at least 0.
    !>

    NRU

    !>          NRU is INTEGER
    !>        On entry, NRU specifies the number of rows of
    !>        the matrix U. NRU must be at least 0.
    !>

    NCC

    !>          NCC is INTEGER
    !>        On entry, NCC specifies the number of columns of
    !>        the matrix C. NCC must be at least 0.
    !>

    D

    !>          D is DOUBLE PRECISION array, dimension (N)
    !>        On entry, D contains the diagonal entries of the
    !>        bidiagonal matrix whose SVD is desired. On normal exit,
    !>        D contains the singular values in ascending order.
    !>

    E

    !>          E is DOUBLE PRECISION array.
    !>        dimension is (N-1) if SQRE = 0 and N if SQRE = 1.
    !>        On entry, the entries of E contain the offdiagonal entries
    !>        of the bidiagonal matrix whose SVD is desired. On normal
    !>        exit, E will contain 0. If the algorithm does not converge,
    !>        D and E will contain the diagonal and superdiagonal entries
    !>        of a bidiagonal matrix orthogonally equivalent to the one
    !>        given as input.
    !>

    VT

    !>          VT is DOUBLE PRECISION array, dimension (LDVT, NCVT)
    !>        On entry, contains a matrix which on exit has been
    !>        premultiplied by P**T, dimension N-by-NCVT if SQRE = 0
    !>        and (N+1)-by-NCVT if SQRE = 1 (not referenced if NCVT=0).
    !>

    LDVT

    !>          LDVT is INTEGER
    !>        On entry, LDVT specifies the leading dimension of VT as
    !>        declared in the calling (sub) program. LDVT must be at
    !>        least 1. If NCVT is nonzero LDVT must also be at least N.
    !>

    U

    !>          U is DOUBLE PRECISION array, dimension (LDU, N)
    !>        On entry, contains a  matrix which on exit has been
    !>        postmultiplied by Q, dimension NRU-by-N if SQRE = 0
    !>        and NRU-by-(N+1) if SQRE = 1 (not referenced if NRU=0).
    !>

    LDU

    !>          LDU is INTEGER
    !>        On entry, LDU  specifies the leading dimension of U as
    !>        declared in the calling (sub) program. LDU must be at
    !>        least max( 1, NRU ) .
    !>

    C

    !>          C is DOUBLE PRECISION array, dimension (LDC, NCC)
    !>        On entry, contains an N-by-NCC matrix which on exit
    !>        has been premultiplied by Q**T  dimension N-by-NCC if SQRE = 0
    !>        and (N+1)-by-NCC if SQRE = 1 (not referenced if NCC=0).
    !>

    LDC

    !>          LDC is INTEGER
    !>        On entry, LDC  specifies the leading dimension of C as
    !>        declared in the calling (sub) program. LDC must be at
    !>        least 1. If NCC is nonzero, LDC must also be at least N.
    !>

    WORK

    !>          WORK is DOUBLE PRECISION array, dimension (4*N)
    !>        Workspace. Only referenced if one of NCVT, NRU, or NCC is
    !>        nonzero, and if N is at least 2.
    !>

    INFO

    !>          INFO is INTEGER
    !>        On exit, a value of 0 indicates a successful exit.
    !>        If INFO < 0, argument number -INFO is illegal.
    !>        If INFO > 0, the algorithm did not converge, and INFO
    !>        specifies how many superdiagonals did not converge.
    !>

Author
    Univ. of Tennessee

    Univ. of California Berkeley

    Univ. of Colorado Denver

    NAG Ltd.

Contributors:
    Ming Gu and Huan Ren, Computer Science Division, University of California at Berkeley, USA

  subroutine slasdq (character uplo, integer sqre, 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)

SLASDQ computes the SVD of a real bidiagonal matrix with diagonal d and off-diagonal e. Used by sbdsdc.

Purpose:

    !>
    !> SLASDQ computes the singular value decomposition (SVD) of a real
    !> (upper or lower) bidiagonal matrix with diagonal D and offdiagonal
    !> E, accumulating the transformations if desired. Letting B denote
    !> the input bidiagonal matrix, the algorithm computes orthogonal
    !> matrices Q and P such that B = Q * S * P**T (P**T denotes the transpose
    !> of P). The singular values S are overwritten on D.
    !>
    !> The input matrix U  is changed to U  * Q  if desired.
    !> The input matrix VT is changed to P**T * VT if desired.
    !> The input matrix C  is changed to Q**T * C  if desired.
    !>
    !> See  by J. Demmel and W. Kahan,
    !> LAPACK Working Note #3, for a detailed description of the algorithm.
    !>

Parameters
    UPLO

    !>          UPLO is CHARACTER*1
    !>        On entry, UPLO specifies whether the input bidiagonal matrix
    !>        is upper or lower bidiagonal, and whether it is square are
    !>        not.
    !>           UPLO = 'U' or 'u'   B is upper bidiagonal.
    !>           UPLO = 'L' or 'l'   B is lower bidiagonal.
    !>

    SQRE

    !>          SQRE is INTEGER
    !>        = 0: then the input matrix is N-by-N.
    !>        = 1: then the input matrix is N-by-(N+1) if UPLU = 'U' and
    !>             (N+1)-by-N if UPLU = 'L'.
    !>
    !>        The bidiagonal matrix has
    !>        N = NL + NR + 1 rows and
    !>        M = N + SQRE >= N columns.
    !>

    N

    !>          N is INTEGER
    !>        On entry, N specifies the number of rows and columns
    !>        in the matrix. N must be at least 0.
    !>

    NCVT

    !>          NCVT is INTEGER
    !>        On entry, NCVT specifies the number of columns of
    !>        the matrix VT. NCVT must be at least 0.
    !>

    NRU

    !>          NRU is INTEGER
    !>        On entry, NRU specifies the number of rows of
    !>        the matrix U. NRU must be at least 0.
    !>

    NCC

    !>          NCC is INTEGER
    !>        On entry, NCC specifies the number of columns of
    !>        the matrix C. NCC must be at least 0.
    !>

    D

    !>          D is REAL array, dimension (N)
    !>        On entry, D contains the diagonal entries of the
    !>        bidiagonal matrix whose SVD is desired. On normal exit,
    !>        D contains the singular values in ascending order.
    !>

    E

    !>          E is REAL array.
    !>        dimension is (N-1) if SQRE = 0 and N if SQRE = 1.
    !>        On entry, the entries of E contain the offdiagonal entries
    !>        of the bidiagonal matrix whose SVD is desired. On normal
    !>        exit, E will contain 0. If the algorithm does not converge,
    !>        D and E will contain the diagonal and superdiagonal entries
    !>        of a bidiagonal matrix orthogonally equivalent to the one
    !>        given as input.
    !>

    VT

    !>          VT is REAL array, dimension (LDVT, NCVT)
    !>        On entry, contains a matrix which on exit has been
    !>        premultiplied by P**T, dimension N-by-NCVT if SQRE = 0
    !>        and (N+1)-by-NCVT if SQRE = 1 (not referenced if NCVT=0).
    !>

    LDVT

    !>          LDVT is INTEGER
    !>        On entry, LDVT specifies the leading dimension of VT as
    !>        declared in the calling (sub) program. LDVT must be at
    !>        least 1. If NCVT is nonzero LDVT must also be at least N.
    !>

    U

    !>          U is REAL array, dimension (LDU, N)
    !>        On entry, contains a  matrix which on exit has been
    !>        postmultiplied by Q, dimension NRU-by-N if SQRE = 0
    !>        and NRU-by-(N+1) if SQRE = 1 (not referenced if NRU=0).
    !>

    LDU

    !>          LDU is INTEGER
    !>        On entry, LDU  specifies the leading dimension of U as
    !>        declared in the calling (sub) program. LDU must be at
    !>        least max( 1, NRU ) .
    !>

    C

    !>          C is REAL array, dimension (LDC, NCC)
    !>        On entry, contains an N-by-NCC matrix which on exit
    !>        has been premultiplied by Q**T  dimension N-by-NCC if SQRE = 0
    !>        and (N+1)-by-NCC if SQRE = 1 (not referenced if NCC=0).
    !>

    LDC

    !>          LDC is INTEGER
    !>        On entry, LDC  specifies the leading dimension of C as
    !>        declared in the calling (sub) program. LDC must be at
    !>        least 1. If NCC is nonzero, LDC must also be at least N.
    !>

    WORK

    !>          WORK is REAL array, dimension (4*N)
    !>        Workspace. Only referenced if one of NCVT, NRU, or NCC is
    !>        nonzero, and if N is at least 2.
    !>

    INFO

    !>          INFO is INTEGER
    !>        On exit, a value of 0 indicates a successful exit.
    !>        If INFO < 0, argument number -INFO is illegal.
    !>        If INFO > 0, the algorithm did not converge, and INFO
    !>        specifies how many superdiagonals did not converge.
    !>

Author
    Univ. of Tennessee

    Univ. of California Berkeley

    Univ. of Colorado Denver

    NAG Ltd.

Contributors:
    Ming Gu and Huan Ren, Computer Science Division, University of California at Berkeley, USA

Author

Generated automatically by Doxygen for LAPACK from the source code.