---
name: "dlasd2.f"
section: "3"
platform: "linux"
package: "lapack-doc"
version: "3.12.1-2"
release: "Arch Linux 2026-11-01"
platforms: ["linux"]
url: "https://new.carta.tech/dlasd2.f"
---

# dlasd2.f(3)

## NAME

SRC/dlasd2.f

## SYNOPSIS

### Functions/Subroutines

subroutine **dlasd2** (nl, nr, sqre, k, d, z, alpha, beta, u, ldu, vt, ldvt, dsigma, u2, ldu2, vt2, ldvt2, idxp, idx, idxc, idxq, coltyp, info)\
 **DLASD2** merges the two sets of singular values together into a single sorted set. Used by sbdsdc.

## Function/Subroutine Documentation

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

**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**

*NL*

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

*NR*

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

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

*K*

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

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

*Z*

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

*ALPHA*

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

*BETA*

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

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

*LDU*

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

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

*LDVT*

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

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

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

*LDU2*

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

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

*LDVT2*

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

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

*IDX*

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

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

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

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

*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

Definition at line **266** of file **dlasd2.f**.

## Author

Generated automatically by Doxygen for LAPACK from the source code.