## MB02NY

### Separation of a zero singular value of a bidiagonal submatrix

[Specification] [Arguments] [Method] [References] [Comments] [Example]

Purpose

```  To separate a zero singular value of a bidiagonal submatrix of
order k, k <= p, of the bidiagonal matrix

|Q(1) E(1)  0    ...   0   |
| 0   Q(2) E(2)        .   |
J = | .                    .   |
| .                  E(p-1)|
| 0   ...  ...   ...  Q(p) |

with p = MIN(M,N), by annihilating one or two superdiagonal
elements E(i-1) (if i > 1) and/or E(i) (if i < k).

```
Specification
```      SUBROUTINE MB02NY( UPDATU, UPDATV, M, N, I, K, Q, E, U, LDU, V,
\$                   LDV, DWORK )
C     .. Scalar Arguments ..
LOGICAL           UPDATU, UPDATV
INTEGER           I, K, LDU, LDV, M, N
C     .. Array Arguments ..
DOUBLE PRECISION  DWORK(*), E(*), Q(*), U(LDU,*), V(LDV,*)

```
Arguments

Mode Parameters

```  UPDATU  LOGICAL
Indicates whether the user wishes to accumulate in a
matrix U the left-hand Givens rotations S, as follows:
= .FALSE.:  Do not form U;
= .TRUE. :  The given matrix U is updated (postmultiplied)
by the left-hand Givens rotations S.

UPDATV  LOGICAL
Indicates whether the user wishes to accumulate in a
matrix V the right-hand Givens rotations T, as follows:
= .FALSE.:  Do not form V;
= .TRUE. :  The given matrix V is updated (postmultiplied)
by the right-hand Givens rotations T.

```
Input/Output Parameters
```  M       (input) INTEGER
The number of rows of the matrix U.  M >= 0.

N       (input) INTEGER
The number of rows of the matrix V.  N >= 0.

I       (input) INTEGER
The index of the negligible diagonal entry Q(I) of the
bidiagonal matrix J, I <= p.

K       (input) INTEGER
The index of the last diagonal entry of the considered
bidiagonal submatrix of J, i.e., E(K-1) is considered
negligible, K <= p.

Q       (input/output) DOUBLE PRECISION array, dimension (p)
where p = MIN(M,N).
On entry, Q must contain the diagonal entries of the
bidiagonal matrix J.
On exit, Q contains the diagonal entries of the
transformed bidiagonal matrix S' J T.

E       (input/output) DOUBLE PRECISION array, dimension (p-1)
On entry, E must contain the superdiagonal entries of J.
On exit, E contains the superdiagonal entries of the
transformed bidiagonal matrix S' J T.

U       (input/output) DOUBLE PRECISION array, dimension (LDU,p)
On entry, if UPDATU = .TRUE., U must contain the M-by-p
left transformation matrix.
On exit, if UPDATU = .TRUE., the Givens rotations S on the
left, annihilating E(i) if i < k, have been postmultiplied
into U.
U is not referenced if UPDATU = .FALSE..

LDU     INTEGER
The leading dimension of the array U.
LDU >= max(1,M) if UPDATU = .TRUE.;
LDU >= 1        if UPDATU = .FALSE..

V       (input/output) DOUBLE PRECISION array, dimension (LDV,p)
On entry, if UPDATV = .TRUE., V must contain the N-by-p
right transformation matrix.
On exit, if UPDATV = .TRUE., the Givens rotations T on the
right, annihilating E(i-1) if i > 1,  have been
postmultiplied into V.
V is not referenced if UPDATV = .FALSE..

LDV     INTEGER
The leading dimension of the array V.
LDV >= max(1,N) if UPDATV = .TRUE.;
LDV >= 1        if UPDATV = .FALSE..

```
Workspace
```  DWORK   DOUBLE PRECISION array, dimension (MAX(1,LDWORK))
LDWORK >= 2*MAX(K-I,I-1),  if UPDATV = UPDATU = .TRUE.;
LDWORK >= 2*(K-I), if UPDATU = .TRUE., UPDATV = .FALSE.;
LDWORK >= 2*(I-1), if UPDATV = .TRUE., UPDATU = .FALSE.;
LDWORK >= 1,       if UPDATU = UPDATV = .FALSE..

```
Method
```  Let the considered bidiagonal submatrix be

|Q(1) E(1)  0                    ...   0   |
| 0   Q(2) E(2)                        .   |
| .                                    .   |
| .           Q(i-1) E(i-1)            .   |
Jk = | .                   Q(i) E(i)        .   |.
| .                       Q(i+1) .     .   |
| .                              ..    .   |
| .                                  E(k-1)|
| 0    ...                       ...  Q(k) |

A zero singular value of Jk manifests itself by a zero diagonal
entry Q(i) or in practice, a negligible value of Q(i).
When a negligible diagonal element Q(i) in Jk is present, the
bidiagonal submatrix Jk is split by the routine into 2 or 3
unreduced bidiagonal submatrices by annihilating E(i) (if i < k)
using Givens rotations S on the left and by annihilating E(i-1)
(if i > 1) using Givens rotations T on the right until Jk is
reduced to the form:

|Q(1) E(1)  0                ...   0   |
| 0         .                ...   .   |
| .                          ...   .   |
| .       Q(i-1) 0                 .   |
S' Jk T = | .              0   0             .   |.
| .                 Q(i+1)   .     .   |
| .                          ..    .   |
| .                              E(k-1)|
| 0    ...                   ...  Q(k) |

For more details, see [1, pp.11.12-11.14].

```
References
```  [1] Dongarra, J.J., Bunch, J.R., Moler C.B. and Stewart, G.W.
LINPACK User's Guide.

```
Numerical Aspects
```  The algorithm is backward stable.

```
```  None
```
Example

Program Text

```  None
```
Program Data
```  None
```
Program Results
```  None
```