Loading...
Searching...
No Matches

## dlasda()

subroutine dlasda | ( | integer | icompq,
|  | integer | smlsiz,
|  | integer | n,
|  | integer | sqre,
|  | double precision, dimension( * ) | d,
|  | double precision, dimension( * ) | e,
|  | double precision, dimension( ldu, * ) | u,
|  | integer | ldu,
|  | double precision, dimension( ldu, * ) | vt,
|  | integer, dimension( * ) | k,
|  | double precision, dimension( ldu, * ) | difl,
|  | double precision, dimension( ldu, * ) | difr,
|  | double precision, dimension( ldu, * ) | z,
|  | double precision, dimension( ldu, * ) | poles,
|  | integer, dimension( * ) | givptr,
|  | integer, dimension( ldgcol, * ) | givcol,
|  | integer | ldgcol,
|  | integer, dimension( ldgcol, * ) | perm,
|  | double precision, dimension( ldu, * ) | givnum,
|  | double precision, dimension( * ) | c,
|  | double precision, dimension( * ) | s,
|  | double precision, dimension( * ) | work,
|  | integer, dimension( * ) | iwork,
|  | integer | info )

DLASDA computes the singular value decomposition (SVD) of a real upper bidiagonal matrix with diagonal d and off-diagonal e. Used by sbdsdc.

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

Purpose:

      !>
      !> Using a divide and conquer approach, DLASDA computes the singular
      !> value decomposition (SVD) of a real upper bidiagonal N-by-M matrix
      !> B with diagonal D and offdiagonal E, where M = N + SQRE. The
      !> algorithm computes the singular values in the SVD B = U * S * VT.
      !> The orthogonal matrices U and VT are optionally computed in
      !> compact form.
      !>
      !> A related subroutine, DLASD0, computes the singular values and
      !> the singular vectors in explicit form.
      !>

Parameters

  [in]

  ICOMPQ

      !>          ICOMPQ is INTEGER
      !>         Specifies whether singular vectors are to be computed
      !>         in compact form, as follows
      !>         = 0: Compute singular values only.
      !>         = 1: Compute singular vectors of upper bidiagonal
      !>              matrix in compact form.
      !>

  [in]

  SMLSIZ

      !>          SMLSIZ is INTEGER
      !>         The maximum size of the subproblems at the bottom of the
      !>         computation tree.
      !>

  [in]

  N

      !>          N is INTEGER
      !>         The row dimension of the upper bidiagonal matrix. This is
      !>         also the dimension of the main diagonal array D.
      !>

  [in]

  SQRE

      !>          SQRE is INTEGER
      !>         Specifies the column dimension of the bidiagonal matrix.
      !>         = 0: The bidiagonal matrix has column dimension M = N;
      !>         = 1: The bidiagonal matrix has column dimension M = N + 1.
      !>

  [in,out]

  D

      !>          D is DOUBLE PRECISION array, dimension ( N )
      !>         On entry D contains the main diagonal of the bidiagonal
      !>         matrix. On exit D, if INFO = 0, contains its singular values.
      !>

  [in]

  E

      !>          E is DOUBLE PRECISION array, dimension ( M-1 )
      !>         Contains the subdiagonal entries of the bidiagonal matrix.
      !>         On exit, E has been destroyed.
      !>

  [out]

  U

      !>          U is DOUBLE PRECISION array,
      !>         dimension ( LDU, SMLSIZ ) if ICOMPQ = 1, and not referenced
      !>         if ICOMPQ = 0. If ICOMPQ = 1, on exit, U contains the left
      !>         singular vector matrices of all subproblems at the bottom
      !>         level.
      !>

  [in]

  LDU

      !>          LDU is INTEGER, LDU = > N.
      !>         The leading dimension of arrays U, VT, DIFL, DIFR, POLES,
      !>         GIVNUM, and Z.
      !>

  [out]

  VT

      !>          VT is DOUBLE PRECISION array,
      !>         dimension ( LDU, SMLSIZ+1 ) if ICOMPQ = 1, and not referenced
      !>         if ICOMPQ = 0. If ICOMPQ = 1, on exit, VT**T contains the right
      !>         singular vector matrices of all subproblems at the bottom
      !>         level.
      !>

  [out]

  K

      !>          K is INTEGER array,
      !>         dimension ( N ) if ICOMPQ = 1 and dimension 1 if ICOMPQ = 0.
      !>         If ICOMPQ = 1, on exit, K(I) is the dimension of the I-th
      !>         secular equation on the computation tree.
      !>

  [out]

  DIFL

      !>          DIFL is DOUBLE PRECISION array, dimension ( LDU, NLVL ),
      !>         where NLVL = floor(log_2 (N/SMLSIZ))).
      !>

  [out]

  DIFR

      !>          DIFR is DOUBLE PRECISION array,
      !>                  dimension ( LDU, 2 * NLVL ) if ICOMPQ = 1 and
      !>                  dimension ( N ) if ICOMPQ = 0.
      !>         If ICOMPQ = 1, on exit, DIFL(1:N, I) and DIFR(1:N, 2 * I - 1)
      !>         record distances between singular values on the I-th
      !>         level and singular values on the (I -1)-th level, and
      !>         DIFR(1:N, 2 * I ) contains the normalizing factors for
      !>         the right singular vector matrix. See DLASD8 for details.
      !>

  [out]

  Z

      !>          Z is DOUBLE PRECISION array,
      !>                  dimension ( LDU, NLVL ) if ICOMPQ = 1 and
      !>                  dimension ( N ) if ICOMPQ = 0.
      !>         The first K elements of Z(1, I) contain the components of
      !>         the deflation-adjusted updating row vector for subproblems
      !>         on the I-th level.
      !>

  [out]

  POLES

      !>          POLES is DOUBLE PRECISION array,
      !>         dimension ( LDU, 2 * NLVL ) if ICOMPQ = 1, and not referenced
      !>         if ICOMPQ = 0. If ICOMPQ = 1, on exit, POLES(1, 2*I - 1) and
      !>         POLES(1, 2*I) contain  the new and old singular values
      !>         involved in the secular equations on the I-th level.
      !>

  [out]

  GIVPTR

      !>          GIVPTR is INTEGER array,
      !>         dimension ( N ) if ICOMPQ = 1, and not referenced if
      !>         ICOMPQ = 0. If ICOMPQ = 1, on exit, GIVPTR( I ) records
      !>         the number of Givens rotations performed on the I-th
      !>         problem on the computation tree.
      !>

  [out]

  GIVCOL

      !>          GIVCOL is INTEGER array,
      !>         dimension ( LDGCOL, 2 * NLVL ) if ICOMPQ = 1, and not
      !>         referenced if ICOMPQ = 0. If ICOMPQ = 1, on exit, for each I,
      !>         GIVCOL(1, 2 *I - 1) and GIVCOL(1, 2 *I) record the locations
      !>         of Givens rotations performed on the I-th level on the
      !>         computation tree.
      !>

  [in]

  LDGCOL

      !>          LDGCOL is INTEGER, LDGCOL = > N.
      !>         The leading dimension of arrays GIVCOL and PERM.
      !>

  [out]

  PERM

      !>          PERM is INTEGER array,
      !>         dimension ( LDGCOL, NLVL ) if ICOMPQ = 1, and not referenced
      !>         if ICOMPQ = 0. If ICOMPQ = 1, on exit, PERM(1, I) records
      !>         permutations done on the I-th level of the computation tree.
      !>

  [out]

  GIVNUM

      !>          GIVNUM is DOUBLE PRECISION array,
      !>         dimension ( LDU,  2 * NLVL ) if ICOMPQ = 1, and not
      !>         referenced if ICOMPQ = 0. If ICOMPQ = 1, on exit, for each I,
      !>         GIVNUM(1, 2 *I - 1) and GIVNUM(1, 2 *I) record the C- and S-
      !>         values of Givens rotations performed on the I-th level on
      !>         the computation tree.
      !>

  [out]

  C

      !>          C is DOUBLE PRECISION array,
      !>         dimension ( N ) if ICOMPQ = 1, and dimension 1 if ICOMPQ = 0.
      !>         If ICOMPQ = 1 and the I-th subproblem is not square, on exit,
      !>         C( I ) contains the C-value of a Givens rotation related to
      !>         the right null space of the I-th subproblem.
      !>

  [out]

  S

      !>          S is DOUBLE PRECISION array, dimension ( N ) if
      !>         ICOMPQ = 1, and dimension 1 if ICOMPQ = 0. If ICOMPQ = 1
      !>         and the I-th subproblem is not square, on exit, S( I )
      !>         contains the S-value of a Givens rotation related to
      !>         the right null space of the I-th subproblem.
      !>

  [out]

  WORK

      !>          WORK is DOUBLE PRECISION array, dimension
      !>         (6 * N + (SMLSIZ + 1)*(SMLSIZ + 1)).
      !>

  [out]

  IWORK

      !>          IWORK is INTEGER array, dimension (7*N)
      !>

  [out]

  INFO

      !>          INFO is INTEGER
      !>          = 0:  successful exit.
      !>          < 0:  if INFO = -i, the i-th argument had an illegal value.
      !>          > 0:  if INFO = 1, a singular value 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