Loading...
Searching...
No Matches

## dlasd2()

subroutine dlasd2 | ( | integer | nl,
|  | integer | nr,
|  | integer | sqre,
|  | integer | k,
|  | double precision, dimension( * ) | d,
|  | double precision, dimension( * ) | z,
|  | double precision | alpha,
|  | double precision | beta,
|  | double precision, dimension( ldu, * ) | u,
|  | integer | ldu,
|  | double precision, dimension( ldvt, * ) | vt,
|  | integer | ldvt,
|  | double precision, dimension( * ) | dsigma,
|  | double precision, dimension( ldu2, * ) | u2,
|  | integer | ldu2,
|  | double precision, dimension( ldvt2, * ) | vt2,
|  | integer | ldvt2,
|  | integer, dimension( * ) | idxp,
|  | integer, dimension( * ) | idx,
|  | integer, dimension( * ) | idxc,
|  | integer, dimension( * ) | idxq,
|  | integer, dimension( * ) | coltyp,
|  | integer | info )

DLASD2 merges the two sets of singular values together into a single sorted set. Used by sbdsdc.

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

Purpose:

      !>
      !> DLASD2 merges the two sets of singular values together into a single
      !> sorted set.  Then it tries to deflate the size of the problem.
      !> There are two ways in which deflation can occur:  when two or more
      !> singular values are close together or if there is a tiny entry in the
      !> Z vector.  For each such occurrence the order of the related secular
      !> equation problem is reduced by one.
      !>
      !> DLASD2 is called from DLASD1.
      !>

Parameters

  [in]

  NL

      !>          NL is INTEGER
      !>         The row dimension of the upper block.  NL >= 1.
      !>

  [in]

  NR

      !>          NR is INTEGER
      !>         The row dimension of the lower block.  NR >= 1.
      !>

  [in]

  SQRE

      !>          SQRE is INTEGER
      !>         = 0: the lower block is an NR-by-NR square matrix.
      !>         = 1: the lower block is an NR-by-(NR+1) rectangular matrix.
      !>
      !>         The bidiagonal matrix has N = NL + NR + 1 rows and
      !>         M = N + SQRE >= N columns.
      !>

  [out]

  K

      !>          K is INTEGER
      !>         Contains the dimension of the non-deflated matrix,
      !>         This is the order of the related secular equation. 1 <= K <=N.
      !>

  [in,out]

  D

      !>          D is DOUBLE PRECISION array, dimension(N)
      !>         On entry D contains the singular values of the two submatrices
      !>         to be combined.  On exit D contains the trailing (N-K) updated
      !>         singular values (those which were deflated) sorted into
      !>         increasing order.
      !>

  [out]

  Z

      !>          Z is DOUBLE PRECISION array, dimension(N)
      !>         On exit Z contains the updating row vector in the secular
      !>         equation.
      !>

  [in]

  ALPHA

      !>          ALPHA is DOUBLE PRECISION
      !>         Contains the diagonal element associated with the added row.
      !>

  [in]

  BETA

      !>          BETA is DOUBLE PRECISION
      !>         Contains the off-diagonal element associated with the added
      !>         row.
      !>

  [in,out]

  U

      !>          U is DOUBLE PRECISION array, dimension(LDU,N)
      !>         On entry U contains the left singular vectors of two
      !>         submatrices in the two square blocks with corners at (1,1),
      !>         (NL, NL), and (NL+2, NL+2), (N,N).
      !>         On exit U contains the trailing (N-K) updated left singular
      !>         vectors (those which were deflated) in its last N-K columns.
      !>

  [in]

  LDU

      !>          LDU is INTEGER
      !>         The leading dimension of the array U.  LDU >= N.
      !>

  [in,out]

  VT

      !>          VT is DOUBLE PRECISION array, dimension(LDVT,M)
      !>         On entry VT**T contains the right singular vectors of two
      !>         submatrices in the two square blocks with corners at (1,1),
      !>         (NL+1, NL+1), and (NL+2, NL+2), (M,M).
      !>         On exit VT**T contains the trailing (N-K) updated right singular
      !>         vectors (those which were deflated) in its last N-K columns.
      !>         In case SQRE =1, the last row of VT spans the right null
      !>         space.
      !>

  [in]

  LDVT

      !>          LDVT is INTEGER
      !>         The leading dimension of the array VT.  LDVT >= M.
      !>

  [out]

  DSIGMA

      !>          DSIGMA is DOUBLE PRECISION array, dimension (N)
      !>         Contains a copy of the diagonal elements (K-1 singular values
      !>         and one zero) in the secular equation.
      !>

  [out]

  U2

      !>          U2 is DOUBLE PRECISION array, dimension(LDU2,N)
      !>         Contains a copy of the first K-1 left singular vectors which
      !>         will be used by DLASD3 in a matrix multiply (DGEMM) to solve
      !>         for the new left singular vectors. U2 is arranged into four
      !>         blocks. The first block contains a column with 1 at NL+1 and
      !>         zero everywhere else; the second block contains non-zero
      !>         entries only at and above NL; the third contains non-zero
      !>         entries only below NL+1; and the fourth is dense.
      !>

  [in]

  LDU2

      !>          LDU2 is INTEGER
      !>         The leading dimension of the array U2.  LDU2 >= N.
      !>

  [out]

  VT2

      !>          VT2 is DOUBLE PRECISION array, dimension(LDVT2,N)
      !>         VT2**T contains a copy of the first K right singular vectors
      !>         which will be used by DLASD3 in a matrix multiply (DGEMM) to
      !>         solve for the new right singular vectors. VT2 is arranged into
      !>         three blocks. The first block contains a row that corresponds
      !>         to the special 0 diagonal element in SIGMA; the second block
      !>         contains non-zeros only at and before NL +1; the third block
      !>         contains non-zeros only at and after  NL +2.
      !>

  [in]

  LDVT2

      !>          LDVT2 is INTEGER
      !>         The leading dimension of the array VT2.  LDVT2 >= M.
      !>

  [out]

  IDXP

      !>          IDXP is INTEGER array, dimension(N)
      !>         This will contain the permutation used to place deflated
      !>         values of D at the end of the array. On output IDXP(2:K)
      !>         points to the nondeflated D-values and IDXP(K+1:N)
      !>         points to the deflated singular values.
      !>

  [out]

  IDX

      !>          IDX is INTEGER array, dimension(N)
      !>         This will contain the permutation used to sort the contents of
      !>         D into ascending order.
      !>

  [out]

  IDXC

      !>          IDXC is INTEGER array, dimension(N)
      !>         This will contain the permutation used to arrange the columns
      !>         of the deflated U matrix into three groups:  the first group
      !>         contains non-zero entries only at and above NL, the second
      !>         contains non-zero entries only below NL+2, and the third is
      !>         dense.
      !>

  [in,out]

  IDXQ

      !>          IDXQ is INTEGER array, dimension(N)
      !>         This contains the permutation which separately sorts the two
      !>         sub-problems in D into ascending order.  Note that entries in
      !>         the first hlaf of this permutation must first be moved one
      !>         position backward; and entries in the second half
      !>         must first have NL+1 added to their values.
      !>

  [out]

  COLTYP

      !>          COLTYP is INTEGER array, dimension(N)
      !>         As workspace, this will contain a label which will indicate
      !>         which of the following types a column in the U2 matrix or a
      !>         row in the VT2 matrix is:
      !>         1 : non-zero in the upper half only
      !>         2 : non-zero in the lower half only
      !>         3 : dense
      !>         4 : deflated
      !>
      !>         On exit, it is an array of dimension 4, with COLTYP(I) being
      !>         the dimension of the I-th type columns.
      !>

  [out]

  INFO

      !>          INFO is INTEGER
      !>          = 0:  successful exit.
      !>          < 0:  if INFO = -i, the i-th argument had an illegal value.
      !>

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